DEV Community: suresh chandra sekar

Go Learning Journey: Part 1 - Setting Up and First Impressions

suresh chandra sekar — Sat, 22 Mar 2025 16:24:48 +0000

Go's, like, everywhere—cloud computing, backend services... you name it! It's known for being simple, super fast, and handling lots of things at once. Tons of developers swear by it. But, is it really that easy for beginners? Well, instead of just following some boring tutorial, I'm getting my hands dirty—learning Go and sharing what I find, the good and the bad, as I go.

Setting Up Go (Easier Than I Thought!)

Setting up Go is pretty straightforward, and here's how you can do it on different operating systems.

Installing on Linux

Download Go: Grab the latest Go archive from the official downloads page. You can use wgetin your terminal:

wget https://go.dev/dl/go1.21.6.linux-amd64.tar.gz # Replace with the actual version

Extract the archive: Extract the downloaded archive to /usr/local:

sudo tar -C /usr/local -xzf go1.21.6.linux-amd64.tar.gz

Set up environment variables: Add Go's binary directory to your PATH by adding this line to your ~/.profile or ~/.bashrc file

export PATH=$PATH:/usr/local/go/bin

Then, apply the changes:
source ~/.profile or source ~/.bashrc
Verify installation: Check if Go is installed correctly:

go version

Installing on macOS
Download Go: Download the .pkg installer from the official Go downloads page.

Install Go: Run the .pkg file and follow the instructions. Go will be installed to /usr/local/go.

Set up environment variables: Add Go to your PATH by adding this line to your ~/.bash_profile or ~/.zshrc file:

echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.bash_profile source ~/.bash_profile

Verify Installation: Run the following command

go version

Installing on Windows

Download Go: Download the .msi installer from the official Go downloads page.

Install Go: Run the .msi installer and follow the instructions.

Set up Environment Variables: The installer usually sets the necessary environment variables. If not, add C:\Program Files\Go\bin to the Path variable in your system environment settings.

Verify Installation: Open a command prompt and type:

go version

Writing My First Go Program

Now that Go is set up, let's write a simple program to make sure everything's working and to get a feel for the Go language. It's tradition to start with a "Hello, World" program, so that's what we'll do!

Create the Go file: Now, we'll create a file to hold our Go code. We'll name it main.go. You can use any text editor you like (VS Code, Notepad, Nano, Vim, etc.). Inside your text editor, type the following Go code

package main

import "fmt"

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

package main: This line declares the package that this code belongs to. Every Go program must belong to a package. The main package is special; it tells the Go compiler that this code is the entry point of an executable program.
import "fmt": This line imports the fmt package, which provides functions for formatted input and output. In this case, we're using the fmt.Println function.
func main() { ... }: This is the main function. It's the function that gets executed when you run the program. The code inside the curly braces {} is what the function does.
fmt.Println("Hello, World!"): This line is the heart of the program. It calls the Println function from the fmt package to print the text "Hello, World!" to the console. Println adds a newline character to the end of the output.
Save the file: Save the main.go file in your text editor. If you're using Nano, you can press Ctrl+O to save, and then Ctrl+X to exit.

Run the program: Now, let's run the program! In your terminal or command prompt type the following command:

go run main.go

This command does two things:

go run: This is the Go command that compiles and runs the Go program.

main.go: This specifies the Go file that you want to run.

When you press Enter, you should see the output:

Hello, World!

Congratulations! You've just written and run your first Go program.

🔥 If you enjoyed this post, show some love! 🔥
Your support keeps me motivated to share more insights on learning Go! 🚀

Also, don’t forget to follow me on Medium & Substack for future updates. Let’s grow together!

📖 Medium – Quick, bite-sized tech insights, perfect for your coffee break☕.
📩 Substack – Long-form guides, industry trends, and expert interviews.

How Gaming Led Me to Programming

suresh chandra sekar — Fri, 14 Mar 2025 17:48:11 +0000

📢 Disclaimer: This is just my personal journey

A Gamer With No Direction 🎮

If you had asked me in school what I wanted to become, I wouldn’t have had an answer. I had no idea about my future. The only thing that truly made me happy was gaming. Whether I was happy or sad, I would spend hours in front of my PC, grinding for 6 to 7 hours straight. That was my life.

I took Computer Science in high school and later went to college for Software Engineering, but to be honest, I was still clueless. I wasn’t passionate about academics, and the education system didn’t really help. It wasn’t inspiring; it was just memorization.

Curiosity Sparked: I Wanted to Build Something 🔥

Did anyone hear about the guy who built RollerCoaster Tycoon all by himself? That blew my mind. Chris Sawyer, the legend, developed the game mostly in assembly language, making it one of the most optimized games of its time.

Despite my confusion, I had a curiosity—I wanted to build something on my own, even if it was complete crap. The idea of creating something from nothing fascinated me. So, I decided to give programming a try.

But there was a problem—I knew nothing about coding. In school, I had studied C/C++, but writing code on your own without guidance was a whole different challenge. I didn’t even know where to start.

With no guidance, I turned to YouTube, and that’s where I found these channel who introduced me to programming:

🔥 Clever Programmer
🔥 Corey Schafer
🔥 thenewboston
🔥 Caleb Curry

These guys changed my life. Thanks to them, programming no longer felt like a boring subject; it became something fun and creative.

The Struggles of Choosing a Language 🤯

At first, I was overwhelmed. There were so many languages—C++, Java, JavaScript, and more. I had no idea which one to focus on.

Then, in my second year of college, I discovered Python 🐍. People called it the best programming language for beginners, and for the first time, programming actually made sense to me.

Python’s simplicity and versatility made learning fun, and it helped me understand Object-Oriented Programming (OOP). I started experimenting with small scripts, automating tasks, and building basic web applications.

Building Small Tools & Gaining Confidence 💡

Once I started learning Python, I got addicted to building things. Here are some of my early projects:

✅ Scraping movie data using BeautifulSoup and Requests
✅ YouTube video downloader
✅ Screen recorder in Python
✅ Fun with Termux – Automating tasks on Android using terminal commands

These weren’t groundbreaking projects, but they gave me confidence. Each time I completed something, I felt like I was leveling up in a game.

My Third Year: Java & The Realization 😩

In my third year, I had to learn Java. I won’t lie—I didn’t like it. Something about Java just didn’t click with me. Maybe it was personal preference, maybe it was the way I learned it. Don’t judge me. 😆

That’s when I realized: It’s okay not to love every language. You don’t have to force yourself to like something just because it’s popular.

The Harsh Reality: Job Rejections 🚪❌

After college, I faced rejection after rejection. More than 40 companies turned me down. I kept applying, improving my skills, and trying again.

It was frustrating, but I didn’t give up. I kept building projects and learning every day. Looking back, those rejections were just stepping stones to where I am now

Breaking Into the Cloud Product Space ☁️

After two years of dedication, I finally landed a job at a cloud product-based company. I played a crucial role in developing several key features for their product. It was an amazing experience—getting paid to do what I loved and working on real-world projects

The Hard Truth: Learn Low-Level Programming ⚠️:

One mistake I made was not learning low-level programming early on. Python is great for beginners, but you can’t stay there forever. It took me five years to realize that understanding low-level concepts like memory management, operating systems, and algorithms is crucial if you want to become a solid developer.

So, if you’re just starting out, don’t skip C, C++, or even Java. It might seem intimidating, but trust me—it will make you a better programmer in the long run.

Final Thoughts: Keep Grinding! 💪

Looking back, my journey wasn’t smooth. I started clueless, struggled, failed, and faced rejection. But I kept grinding.

If you’re just starting out, don’t stress about knowing everything right away. Keep learning, keep building, and trust the process. One day, you’ll look back and realize how far you’ve come. 🚀

Why You Should Follow My Tech Journey 🚀

Hi, I’m a developer passionate about making complex tech topics accessible to everyone. If you're eager to stay ahead in tech, here’s what you’ll get by following me:

🔗 Follow me for in-depth tech content:
📖 Medium – Quick, bite-sized tech insights, perfect for your coffee break☕.
📩 Substack – Long-form guides, industry trends, and expert interviews.

Why Rust is the Future of Programming

suresh chandra sekar — Sun, 09 Mar 2025 16:42:50 +0000

Imagine writing code that’s as fast as C++, never crashes due to memory leaks, and makes concurrency a breeze. No, this isn’t a developer’s fantasy—it’s Rust. And if you’re not learning it yet, you’re missing out on a revolution reshaping tech giants like Microsoft, Google, and AWS. Ready to join the movement?

Why Rust? The Language That’s Changing Everything 🌍

The tech world is buzzing about Rust—and for good reason. It’s not just another programming language; Rust is a paradigm shift, blending raw performance with ironclad safety. Here’s why developers are ditching their old tools and embracing Rust

Zero-Cost Abstractions – Write high-level code without sacrificing performance.
Memory Safety Guaranteed – Say goodbye to segfaults, buffer overflows, and dangling pointers.
Fearless Concurrency – Build parallel systems without data races.
A Community That Cares – Rustaceans (yes, that’s what we call ourselves) are famously welcoming.

But here’s the catch: Rust has a learning curve. Concepts like ownership, borrowing, and lifetimes can feel alien at first. Don’t worry—I’ve got your back. Follow me on Medium and Substack for weekly deep dives, pro tips, and exclusive tutorials to turn you from Rust newbie to ninja.

Your First Rust Project: Building a CLI Tool in 10 Minutes ⏱️

Let’s cut through the theory and write real code. You’ll build a simple CLI tool that greets users—and learn core Rust concepts along the way.

Step 1: Set Up Rust

Install Rust in seconds with rustup:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Step 2: Create Your Project

Use cargo, Rust’s built-in package manager:

cargo new hello_rust  
cd hello_rust

Step 3: Write the Code

Open src/main.rs and add:

use std::env;  

fn main() {  
    let args: Vec<String> = env::args().collect();  
    let name = args.get(1).unwrap_or(&"World".to_string());  
    println!("Hello, {}! 🢀", name);  
}

Step 4: Run It! cargo run -- Alice
Boom! You’ve just built a Rust CLI tool. Let’s unpack the magic:

use std::env – Import modules like a pro.
let args: Vec – Rust’s type system keeps you safe.
unwrap_or – Handle errors gracefully—no crashes!

Understand Rust Basics

1. Variables and Mutability
In Rust, variables are immutable by default. This means once a value is assigned, it cannot be changed. To make a variable mutable, use the mut keyword. uselet for variable declaration.

fn main() {
    let x = 5; // immutable
    let mut y = 10; // mutable
    y = 15; // this is allowed
    println!("x = {}, y = {}", x, y);
}

Data Types
Rust is statically typed (you must specify types or let Rust infer them).

Primitive Types

Control Flow

if / else
In Rust, an if statement is similar to Python’s, but with some differences:

Conditions must be explicitly boolean.
if is an expression. That means it can return a value.

fn main() {
    let number = 7;

    if number < 5 {
        println!("Less than 5");
    } else if number == 5 {
        println!("Equal to 5");
    } else {
        println!("Greater than 5");
    }

    // Using if as an expression
    let result = if number % 2 == 0 { "even" } else { "odd" };
    println!("The number is {}", result);
}

Loops: for, while, and loop
Rust offers several ways to loop through code.

for Loop: Iterates over a collection or a range—similar to Python’s for loop.

Example (iterating over an array):

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("Value is: {}", element);
    }
}

Example (using ranges):

fn main() {
    // Iterates from 1 to 5 inclusive
    for number in 1..=5 {
        println!("Number: {}", number);
    }
}

while Loop: Works like Python’s while loop.

fn main() {
    let mut count = 0;
    while count < 5 {
        println!("Count: {}", count);
        count += 1;
    }
}

loop: An infinite loop that runs until you explicitly break out of it.

fn main() {
    let mut counter = 0;
    loop {
        println!("Counter: {}", counter);
        counter += 1;

        if counter == 5 {
            break;  // Exit the loop when counter reaches 5
        }
    }
}

Functions
Functions in Rust are defined using the fn keyword.

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
}

Structs
Structs are used to create custom data types

struct Person {
    name: String,
    age: u8,
}

fn main() {
    let alice = Person {
        name: String::from("Alice"),
        age: 25,
    };
    println!("{} is {} years old.", alice.name, alice.age);
}

Rust Concepts That Will Change How You Code 🔥

Ownership: The Secret to Memory Safety

Rust’s ownership model ensures memory is managed automatically without a garbage collector. Every value has a single "owner," and the compiler tracks its lifecycle.

fn main() {  
    let s1 = String::from("Rust");  
    let s2 = s1; // s1 is "moved" to s2 and invalidated  
    // println!("{}", s1); ← Compiler ERROR!  
    println!("{}", s2); // Works!  
}

Borrowing: Share Resources Safely
Need to pass data around without moving ownership? Borrow it with &:

fn calculate_length(s: &String) -> usize {  
    s.len()  
}  

fn main() {  
    let s = String::from("Hello");  
    let len = calculate_length(&s);  
    println!("Length: {}", len);  
}

Match: Pattern Matching on Steroids
Replace clunky if-else chains with Rust’s match:

fn main() {  
    let number = 3;  
    match number {  
        1 => println!("One"),  
        2 | 3 => println!("Two or Three"),  
        _ => println!("Other"),  
    }  
}

Explore Rust’s Ecosystem

Rust has a rich ecosystem of tools and libraries. Here are a few to get you started:

Cargo: Rust’s package manager and build system. Use it to create new projects, manage dependencies, and run tests.

Crates.io: The official Rust package registry. You can find thousands of libraries (called "crates") to use in your projects.

Tips for Learning Rust 🧠

Take Your Time: Rust has a steep learning curve, especially around concepts like ownership and borrowing. Don’t rush—take time to understand these concepts.

Practice: Write small programs to reinforce your understanding. The more you code, the more comfortable you’ll become.

Join the Community: The Rust community is incredibly supportive. Join forums like the Rust Users Forum or the Rust subreddit to ask questions and share your progress.

Why You Should Follow My Tech Journey 🚀

Hi, I’m a developer passionate about making complex tech topics accessible to everyone. If you're eager to stay ahead in tech, here’s what you’ll get by following me:

✅ Exclusive Tutorials – Deep dives into async Rust, FFI, WebAssembly, and more.

💡 Behind-the-Scenes Insights – Learn how top companies use Rust to power billion-dollar systems.

🔗 Follow me for in-depth tech content:
📖 Medium – Quick, bite-sized tech insights, perfect for your coffee break☕.
📩 Substack – Long-form guides, industry trends, and expert interviews.

🚀 Ready to become a Rustacean? Hit follow and let’s code the future, together.

Python is Slow? Not Anymore! How I Made My Code 100x Faster with Cython (And Why You Should Too)

suresh chandra sekar — Thu, 06 Mar 2025 16:00:16 +0000

Picture this: you’ve written a Python script to process a massive dataset. You hit ‘Run,’ grab a coffee, and settle in for what you think will be a quick wait. But minutes turn into hours, and your code is still chugging along. Sound familiar? That was me just a few weeks ago. Frustrated and racing against a deadline, I discovered something that changed everything: Cython.

Skeptical? I was too. After all, Python is known for being slow, right? But what if I told you that with a few tweaks, you can make your Python code run as fast as C—without rewriting everything from scratch? In this post, I’ll show you how I transformed my sluggish Python script into a speed demon, and why you might want to ditch pure Python for CPU-heavy tasks.

Why is Python Slow?

Python is one of the most popular programming languages, but when it comes to execution speed, it has some well-known drawbacks:

Interpreted Language: Python code runs line by line instead of being compiled into machine code ahead of time.
Global Interpreter Lock (GIL): Python's GIL prevents true multi-threading, limiting CPU-bound performance.
Dynamic Typing: While dynamic typing makes Python flexible, it adds runtime overhead for type checking.

Despite these limitations, Python’s ease of use makes it the go-to language for many developers. But what if you could keep Python’s simplicity and get C-like performance? That’s exactly where Cython comes in.

What is Cython?

Cython is a superset of Python that allows you to write Python code that compiles into highly optimized C code. By adding C data types and removing the GIL (Global Interpreter Lock) where possible, you can achieve speeds close to pure C performance.

With Cython, you can:

Speed up CPU-bound Python code.
Use C data types for faster numerical computations.
Remove the GIL to enable true multi-threading and maximize CPU performance.
Interface with existing C/C++ libraries easily.

Benchmarking Python vs. Cython Performance

using Google Colab, you may need to install it each session:
!pip install cython

Cython code can be compiled using %%cython magic command in Jupyter/Colab:
%load_ext Cython

Let’s start with a simple example: summing numbers from 0 to n.

🔹 Python Version (Slowest)

import time

def python_sum(n):
    total = 0
    for i in range(n):
        total += i
    return total

start = time.time()
python_sum(10**7)  # 10 million iterations
print("Python Execution Time:", time.time() - start)

🔹 Cython Optimized Version
Run this in a separate cell:

%%cython
def cython_sum(int n):
    cdef int total = 0
    cdef int i
    for i in range(n):
        total += i
    return total

start = time.time()
cython_sum(n)
print("Cython Execution Time:", time.time() - start)

Removing GIL for Faster Execution

The GIL (Global Interpreter Lock) limits Python to single-threaded execution. Removing it in Cython allows truly parallel execution.

%%cython
def cython_sum_nogil(int n):
    cdef int total = 0
    cdef int i
    with nogil:
        for i in range(n):
            total += i
    return total

start = time.time()
cython_sum_nogil(n)
print("Cython (No GIL) Execution Time:", time.time() - start)

🔥 Parallelizing with prange (Fastest!)

For multi-core execution, we use prange from cython.parallel.

%%cython
from cython.parallel import prange
cimport cython

@cython.boundscheck(False)
@cython.wraparound(False)
def cython_sum_parallel(int n):
    cdef int total = 0
    cdef int i
    with nogil:
        for i in prange(n, schedule='dynamic', num_threads=4):
            total += i
    return total

start = time.time()
cython_sum_parallel(n)
print("Cython (Parallel No GIL) Execution Time:", time.time() - start)

Conclusion: When to Use Cython?

✅ Use Cython when performance matters, especially for CPU-heavy loops.
✅ Remove GIL for multi-threading without Python’s limitations.
✅ Use prange when working with multi-core processors.

If you need faster numerical computations, also check out Numba (JIT compilation), but for low-level control, Cython is the best! 🔥