Forem: Tanmay Patil

Why You Should Hang Around People Doing Better Than You 💪🏽

Tanmay Patil — Thu, 03 Oct 2024 13:17:44 +0000

I’ve learned something crucial over the years—who you hang around with matters a lot. It shapes your thinking, your actions, and ultimately, your success in every area of life. Whether it’s at work, with family, friends, in the gym, or even in relationships, I’ve seen firsthand how being around people who are doing better than you can shape you in ways you may not even realize.

How Surrounding Yourself with the Right People Helped Me 🌟

1. At Work: Pushing My Limits

In my early years as a software engineer, I used to stick around people who were at my level or, sometimes, even less ambitious. Sure, it was comfortable, but it didn’t push me to grow. One day, I started interacting with people who were killing it in their careers—leaders, senior engineers, and even my boss.

What happened?

I began to challenge myself more. I took on projects that I thought were out of my reach. Their ambition rubbed off on me, and I began to see work not just as a job but as a way to push my limits.

Example:

I noticed that when I hung around senior engineers, I picked up on their problem-solving approaches and mindset. They wouldn’t just solve the immediate issue—they would think about long-term solutions. I started doing the same, and my work improved drastically. 🚀

2. At Home: Family Dynamics

At home, we tend to stick with who we are comfortable with. But I’ve seen the difference between families who support each other’s growth and those who pull each other down. Hanging out with family members who are goal-oriented and positive shaped my own family values.

Example:

I have a cousin who’s always looking for new ways to grow his business, stay fit, and balance family life. Every time I chat with him, I get inspired to set better routines, to dream bigger, and to think of ways I can be a better person at home.

In contrast, I’ve seen family members who constantly complain about their situations, and guess what? Nothing ever changes for them. Staying around people like that would have drained me and probably made me negative too.

3. Social Life: Uplifting vs. Draining People

Your friends shape a huge part of who you are. You might not realize it, but the conversations you have with them influence your thoughts, your decisions, and even your confidence.

When I started spending more time with friends who were doing better in life—financially, mentally, or even just in their energy and attitude—I began to notice a shift in myself. I started thinking bigger and became more goal-oriented. Hanging with people who have a positive mindset makes life feel more like an opportunity and less like a series of problems.

Example:

One of my close friends runs a successful startup, and every time we talk, I walk away feeling like I can take on the world. On the flip side, when I spent time with friends who constantly complained about their jobs or the economy, I noticed it drained my energy and left me feeling negative.

4. In the Gym: You Get What You Surround Yourself With

This one’s simple but powerful. If you’re working out with people who are fitter than you, guess what happens? You push yourself harder. Hanging with gym buddies who are more disciplined has made me more consistent with my workouts and helped me reach goals I thought were out of my reach.

Example:

I have a gym buddy who’s way ahead in terms of fitness. I used to dread leg day (don’t we all? 😅), but seeing him crush it made me realize I could do better. Now, I actually look forward to it because I’m seeing gains I never thought possible. 🏋️‍♂️

The Flip Side: The Danger of Negative People ⚠️

Now, what happens when you hang around people with a negative mindset? They drain your energy, time, and even your resources. It’s not just about wasted hours; it’s about wasted opportunities. You could be investing your time in growth, learning, or building something meaningful, but instead, you’re pulled into a cycle of complaints and excuses.

Example:

A while back, I used to hang out with a group of friends who were always complaining—about their jobs, their relationships, even the weather! I noticed that after spending time with them, I’d feel unmotivated and less productive. It was almost like I was taking on their negative energy.

Eventually, I distanced myself and started hanging out with people who were hustling, growing, and challenging themselves. The difference was night and day. My mood, productivity, and mindset shifted dramatically. ✨

The Investment That Compounds Over Time 📈

Think of surrounding yourself with the right people as an investment. The benefits don’t show up immediately, but over time, they compound. Every conversation, every shared experience with someone who is doing better than you is an opportunity to learn and grow.

Example:

Spending time with successful people helped me improve how I present myself in meetings. I started paying attention to how they communicate, how they handle challenges, and how they think ahead. Slowly but surely, it transformed the way I approached work, and I started getting noticed for it.

How It Shaped My Character and Intellectual Conversations 🧠

One of the most significant changes I noticed was in my conversations. When you hang around people who think critically, who are ambitious, and who are positive, your conversations become more intellectual and thought-provoking.

I found myself engaging in deeper conversations about business strategy, self-improvement, and even global issues. This shaped my character and expanded my worldview. I’m no longer just a participant in conversations; I actively contribute, and I can hold my own in discussions with people far more experienced than I am.

Final Thoughts: Find Opportunities in Problems 🌱

At the end of the day, it’s all about who you choose to surround yourself with. Yes, we all face challenges, whether it’s at work, home, or in the gym, but if you spend time with the right people, you’ll see those challenges as opportunities for growth.

Stop wasting time with people who drain you, and instead, seek out those who inspire you, who challenge you, and who make you want to be better. That’s how

How I Utilise 3 Hours of My Daily Commute Productively 🚗🎧

Tanmay Patil — Thu, 03 Oct 2024 05:28:59 +0000

As a software engineer working at an MNC in the fintech industry- Like many of you, I have big ambitions—I want to grow in my career, take on bigger challenges, and keep learning.

But here’s the thing: growth doesn’t come by sitting around and complaining about things like traffic or wasted commute time. Let’s be real, we all have some form of commute, but if we truly want to get ahead, we need to go the extra mile—literally and figuratively.

In my city (Pune, India), commuting from Akurdi to Magarpatta (that’s 30 km one way) means I spend 1.5 hours on the road in a single trip. So, in total, I spend around 3 hours a day in traffic! 🛣️

I could easily complain about those lost hours, but instead, I found a way to make the most of that time. If you’re aiming to grow and get ahead, it’s crucial to find learning opportunities where others only see obstacles. Here’s how I turned my daily commute into a productivity powerhouse.

"Growth isn’t just about what you do when you’re at your desk; it’s about how you leverage every second you have to improve yourself."

My Daily Commute: The 3-Hour Opportunity 🚗

As I mentioned, my journey from Akurdi to Magarpatta is 1.5 hours each way. Over the week, that adds up to 15 hours in traffic, and if you look at it over a month? That’s 60 hours a month of just sitting in my car. Annually? We’re talking about 780 hours, which is almost 33 full days spent driving! 🤯

But rather than seeing this as wasted time, I’ve managed to turn it into prime learning time. Here’s how!

Turning Traffic Time Into Learning Time 🎧📚

1. Business & Tech Podcasts 🧠💼

Instead of tuning into random radio stations, I fill my commute with business and tech podcasts. These podcasts give me insights into how successful companies operate, the latest trends in the industry, and how to think like an entrepreneur. Listening to podcasts like The Tim Ferriss Show or How I Built This during my drive gives me fresh ideas and inspiration to apply in my own work.

Example:

Just last week, I learned about a unique system design approach from a CTO interview on a tech podcast, and it sparked an idea for improving a current project at work. 💡

2. Audiobooks 📖🎧

Next up: audiobooks. Whether it's self-help, leadership, or technical subjects, audiobooks allow me to dive deep into topics that interest me. Using platforms like Audible and Google Play Books, I can easily turn my car into a moving library!

Example:

I recently finished Atomic Habits during my commute, and I’m already seeing improvements in my daily routines. Who knew that driving could help me build better habits? 🚀

3. CTO Interviews: Learn System Design 👨‍💻🔧

Being in the tech world, I’m always looking for ways to level up my skills. One of my favorite ways to do this is by listening to CTO interviews. These experts often talk about how they’ve scaled their systems, solved complex problems, and approached tech challenges. Listening to them breaks down high-level system designs in a way that’s practical for everyday use.

Example:

After hearing a CTO describe how they handled large-scale data pipelines, I rethought how we could optimize the backend systems at my company.

4. Rotating Podcast Categories 🔄🎙️

To keep things interesting, I rotate between different types of podcasts. On some days, I focus on tech and business, while other days, I switch it up with health, fitness, or even politics. This keeps me engaged, and I feel like I’m constantly growing in multiple areas of life.

Example:

Monday = Business podcasts 📊
Tuesday = Health & Fitness 🏋️‍♂️
Friday = Tech podcasts 🖥️

By the time I arrive at work, I feel like I’ve already learned something valuable!

The Impact: Numbers Speak 📈

3 hours a day x 5 days a week = 15 hours of learning per week.
Multiply that by 4 weeks in a month, and that’s 60 hours a month.
And annually? 780 hours = almost 33 full days of learning!

Instead of losing all those hours in traffic, I’ve gained almost a month of education. Imagine what you can learn in that time—new skills, industry trends, and personal growth all while sitting in your car!

Conclusion: Leverage Every Opportunity 🚀

At the end of the day, we all have to deal with life’s challenges—traffic, long commutes, busy schedules—but how we respond to them makes all the difference. If I had wasted those 3 hours every day, I wouldn’t be growing as much in my career or personal development. Instead, by simply putting on a podcast or audiobook, I’m learning more each day and using my time wisely.

So, don’t let the little inconveniences hold you back. Find opportunities in problems, and turn wasted time into time well spent. Growth isn’t just about what you do when you’re at your desk; it’s about how you leverage every second you have to improve yourself.

Next time you’re stuck in traffic, think of it as your chance to get ahead. 🎧💪

Simplified: Javascript V8 engine ✨

Tanmay Patil — Tue, 01 Oct 2024 04:50:52 +0000

How Does the V8 Engine Really Work?

Ever wondered what happens under the hood when you run JavaScript in your browser? Well, it’s time to introduce you to V8, the magical engine that brings JavaScript to life. Think of V8 as the engine of a car—it's responsible for turning JavaScript into something that your computer can understand and run, smoothly and quickly.

Let’s dive deep into how V8 works, but don’t worry, I’ll keep it fun and simple! 🌟

What Exactly is the V8 Engine? 🧐

The V8 engine is an open-source JavaScript engine developed by Google. It powers Google Chrome and many other environments, like Node.js. Essentially, V8 takes your JavaScript code, compiles it into machine code, and then runs it super fast!

You write JS, and V8 makes sure your machine knows exactly what to do with it.

Step-by-Step: How V8 Works Under the Hood 🔧

1. Parsing: Understanding Your Code 📜

When you write JavaScript, the first thing V8 does is parse your code. It splits your code into small, understandable chunks (called tokens) and creates a syntax tree (AST). This tree is like a map showing how your code is structured.

Example:

let a = 10;
let b = 20;
let sum = a + b;

V8 sees this code and thinks, "Okay, I see two variables and a sum operation."

2. Interpreter (Ignition): Quickly Running Your Code 🏃‍♂️

Once the syntax tree is built, V8 uses something called the Ignition interpreter. The interpreter goes through your code quickly and runs it as it is, but not super fast yet! It’s like giving your code a test run to see how it behaves.

Think of Ignition like the “trial run” mode. It executes the code just-in-time without too much optimization at this point.

3. Profiling: Watching Your Code in Action 👀

As your JavaScript runs, V8 keeps an eye on it. It watches for parts of your code that are being used a lot—these are called hot functions. This is like finding out which gears in a car get used the most during a race.

If a piece of code is executed over and over, V8 flags it and says, “Hey, this part of the code could use some serious optimization!”

4. Optimization (TurboFan): Making it Super Fast 🚗💨

When V8 notices some hot functions, it hands them over to the TurboFan compiler. TurboFan is like the pit crew in a race—it takes your code and optimizes it for speed.

Here’s the magic: TurboFan turns your JavaScript into machine code (the binary 0’s and 1’s that your computer understands). This optimized machine code is much faster than what Ignition initially produced.

Example:

If you have a function that adds two numbers and you call it a lot, TurboFan will make that function as fast as possible.

5. Garbage Collection: Cleaning Up the Mess 🗑️

When you run JavaScript, you often create variables, objects, arrays, etc. Once you're done with them, V8 steps in with garbage collection, a process that automatically frees up memory from stuff you no longer need. This keeps your browser or Node.js server from running out of memory and crashing.

Garbage collection in V8 is smart—it doesn’t just throw stuff away randomly. It uses techniques like mark-and-sweep to carefully track and remove unused data.

What Makes V8 Special? 🌟

1. JIT Compilation ⚡

V8 uses a technique called Just-In-Time (JIT) compilation. This means instead of compiling JavaScript before you run it (like many other languages), V8 compiles your code while it’s running, giving it a huge speed boost in real time!

2. Efficient Memory Management 📉

V8 is great at managing memory. It allocates just the right amount of memory for your variables and functions, and then cleans up after itself when you're done. This ensures your code runs fast and doesn’t waste system resources.

3. Native Support for Modern JavaScript 💡

V8 keeps up with the latest JavaScript features. Whether you're using ES6 classes, async/await, or fancy new syntax like optional chaining (?.), V8 has your back and supports it all efficiently.

Let’s Recap with an Example 🌐

Let’s say you wrote a function to calculate the factorial of a number:

function factorial(n) {
    if (n === 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

console.log(factorial(5)); // Output: 120

Here’s what happens under the hood in V8:

Parsing: V8 converts your function into a syntax tree.
Ignition: It runs the code to see how it performs.
Profiling: It notices that this factorial function is being called multiple times.
TurboFan: V8 optimizes this function into super-fast machine code.
Garbage Collection: Once the function finishes, V8 cleans up the memory used by it.

The Future of V8 🔮

As JavaScript grows, so does V8. Google’s team is constantly improving the engine, focusing on performance, memory efficiency, and support for new JavaScript features.

So, every time you run JavaScript in Chrome or Node.js, know that V8 is working hard behind the scenes, interpreting, optimizing, and managing your code—ensuring your applications run fast and efficiently.

Final Quiz Time! 📝

Here’s a quick quiz to test your V8 knowledge:

What does the V8 engine do with JavaScript code?
What is the role of the Ignition interpreter in V8?
What does JIT compilation stand for?
How does TurboFan optimize your code?
What does V8’s garbage collection process help with?

So that’s V8, simplified! I hope you now have a better understanding of how this mighty engine powers your JavaScript, whether it’s on the web or server-side in Node.js. Happy coding! 😄

💡 How JavaScript Works Under the Hood: A Fun Dive Into the Magic ✨

Tanmay Patil — Tue, 01 Oct 2024 04:42:14 +0000

Ever wonder what happens when you write JavaScript code and hit Run? Where does the magic happen? How does your code actually talk to your computer? Don’t worry, I’m here to guide you through this journey—from your fingers hitting the keyboard to your computer executing your code. And I promise to keep it fun! 😉

1. JavaScript Is Not Magic (But Close Enough!) 🪄

First things first: JavaScript is a high-level, interpreted language. What does that mean? Simply put, it’s like you (the developer) writing a to-do list in English, and your browser is smart enough to read, understand, and act on it—without you needing to know the nitty-gritty machine details.

But here’s the twist: JavaScript needs some help to get to your computer’s brain (the CPU). Your browser (like Chrome, Firefox, etc.) is the hero in this story, and it uses something called a JavaScript engine to make it all happen.

2. Enter the JavaScript Engine: The Super Brain 🧠

At the heart of it all is the JavaScript engine. It’s the piece of software that takes your human-friendly JavaScript code and converts it into machine-friendly language.

Chrome’s JS Engine: V8 🚗

Each browser has its own engine. For example, Chrome uses V8, which is one of the fastest engines out there (it’s also used in Node.js!). Think of V8 like a super-fast car that speeds through your code, converting it into something the computer can understand.

Here’s how the process works:

Parsing (Breaking Down the Code) 🔍 The engine takes your JS code and breaks it down into smaller, understandable pieces. This step is called parsing. It creates something called an Abstract Syntax Tree (AST). Don’t worry, it’s just a fancy way of saying: "Let’s turn this code into something more structured."

Example:

   let num = 5;
   console.log(num);

The engine reads let num = 5; and knows: "Okay, there’s a variable called num with a value of 5. Got it!"

Compilation (Turning Code Into Machine Language) ⚙️

Next, your JS engine compiles (translates) this tree into bytecode. Bytecode is like an intermediate language that’s easier for the computer to understand.
Execution (Let’s Do This! 💥)

The bytecode is now fed into something called an Interpreter. The interpreter runs through the code line by line, executing it on your CPU (which is the actual hardware inside your machine).

So when you run the code:

let num = 5;
console.log(num);

The JavaScript engine does all the heavy lifting, converting that into something your CPU can process and spit out: 5.

3. What About Optimization? 🚀

But wait, JavaScript doesn’t stop there! Modern engines like V8 are incredibly smart. They don’t just interpret your code—they optimize it! While the code is running, the engine constantly looks for ways to make it faster. It uses something called a JIT (Just-In-Time) compiler.

Think of it like this: If you’re running in a race, JIT is like someone handing you better running shoes halfway through. It notices how your code runs and speeds it up on the fly.

Example:

If you have a loop that runs a million times:

for (let i = 0; i < 1000000; i++) {
  console.log(i);
}

JIT notices the pattern and starts optimizing how the loop runs, making it faster every time it goes through.

4. The Event Loop: JavaScript's Secret Weapon 🔄

Now, here’s the fun part: JavaScript is single-threaded. That means it can only do one thing at a time (no multitasking). But wait, how does it handle things like timers, fetch requests, or click events?

Enter the Event Loop. 🎡

The Event Loop is JavaScript’s way of juggling multiple tasks at once. Even though it can only handle one thing at a time, it queues up tasks and processes them one by one—so it feels like it’s doing multiple things at once.

Example:

console.log("Start");

setTimeout(() => {
  console.log("This runs later");
}, 2000);

console.log("End");

In the above code:

"Start" gets logged.
The setTimeout gets pushed to the side (handled by the Event Loop).
"End" gets logged.
After 2 seconds, the Event Loop brings back the setTimeout function, and "This runs later" gets logged.

Even though JavaScript can only do one thing at a time, the Event Loop makes sure everything gets handled smoothly. 🎢

5. From JavaScript to the Browser: The Big Picture 🌐

Okay, let’s zoom out a bit and look at the entire flow:

You write JavaScript in your code editor (or browser console).
The JavaScript engine (V8) reads and compiles your code.
The compiled code gets executed by the browser (or Node.js) on your CPU.
The Event Loop handles any asynchronous tasks (like timers or API requests).
Boom! Your website or app responds to clicks, fetches data, and does all the cool things you’ve coded it to do.

Wrapping Up: JavaScript—It’s Smarter Than You Think 🧠

JavaScript may look like simple lines of code, but behind the scenes, there’s a lot going on. The JavaScript engine (like V8) breaks it down, compiles it, optimizes it, and executes it on your CPU. The Event Loop manages all the asynchronous magic so everything runs smoothly.

So, next time you’re writing a for loop or calling fetch(), remember all the work your browser’s JavaScript engine is doing to bring your code to life! 💡

Please leave a like/comment if you learned something new today ;)

Webpack Simplified: A Beginner’s Guide to Understanding Webpack 🛠️

Tanmay Patil — Tue, 01 Oct 2024 04:20:42 +0000

Alright, let’s talk about Webpack. If you're just starting out in web development, you might have heard people mention Webpack and wondered, "What is this thing? Do I really need it?" Well, let’s break it down in a simple, no-fuss way. By the end of this, you’ll know exactly what Webpack is, why we need it, and how it makes our lives as developers easier!

1. What is Webpack? 🤔

In simple terms, Webpack is a module bundler. But what does that even mean? Think of your web app like a puzzle, where each piece is a module (JavaScript file, CSS, images, etc.). Webpack takes all those pieces and puts them together into a single file (or a few files) called bundles.

Why? So your app can load faster, be easier to manage, and work smoothly. Webpack can also handle complex things like code splitting, minification, and more, but let’s stick to the basics for now.

2. Why Do We Need Webpack? 🛠️

Back in the day, web development was simpler. You had your HTML file, some CSS for styles, and maybe a JavaScript file for functionality. But as apps became more complex, with dozens (or hundreds) of files, managing all those assets got messy.

Without Webpack, we’d have to manually link every single file in the HTML file, like this:

<script src="file1.js"></script>
<script src="file2.js"></script>
<script src="file3.js"></script>
<!-- And this could go on and on... -->

Imagine doing this for a huge project. 😫 Every file you load increases the time it takes for your app to load. Plus, handling dependencies (when one file needs another) manually is like untangling a ball of yarn—it’s a headache.

That’s where Webpack swoops in like a hero! 🦸‍♂️ It bundles all your files, handles dependencies, and optimizes everything for faster loading.

3. How Did Things Work Before Webpack? 🕰️

Before Webpack (and other modern bundlers), things were a bit more... chaotic. Here's how it typically worked:

Multiple Script Tags: Every JavaScript and CSS file had to be linked individually in the HTML. If you had 10 scripts, you'd have 10 <script> tags.
Manual Dependency Management: You had to manually load scripts in the right order. For example, if file2.js depended on file1.js, you had to make sure file1.js was loaded first.
No Automatic Optimizations: There was no built-in way to minify files or split code for better performance. You’d have to do it manually or rely on other tools.

This worked for small websites, but once you started building bigger apps, the process became a nightmare. Enter Webpack. 🎉

4. Benefits of Webpack 🚀

So, why should you care about Webpack? What’s in it for you? Here are some of the key benefits:

1. Bundling All Your Files Together 📦

Webpack bundles all your JavaScript, CSS, images, and other assets into one or a few files. This makes it easier to manage and reduces the number of HTTP requests your browser has to make, speeding up load times.

Example:

Without Webpack:

<script src="app.js"></script>
<script src="utils.js"></script>
<script src="helper.js"></script>

With Webpack:

<script src="bundle.js"></script> <!-- One file for everything! -->

2. Handles Dependencies Automatically 🔗

Webpack automatically figures out which files depend on each other and bundles them in the right order. No more manually sorting through dependencies!

3. Optimizes Your Code for Performance ⚡

Webpack can minify your code (removing spaces and comments to reduce file size) and split your code into smaller bundles. This means your app loads faster, and users aren’t waiting around forever.

4. Hot Module Replacement (HMR) 🔥

When you’re working on a project, Webpack allows you to make changes and see them instantly without having to refresh the entire page. This is called Hot Module Replacement (HMR), and it saves a lot of time.

Example:
Imagine you’re tweaking a button’s style in CSS. With Webpack’s HMR, as soon as you save the file, the change appears in your browser without a page refresh. It’s magic! ✨

5. Extensible with Plugins & Loaders 🛠️

Webpack has a huge ecosystem of plugins and loaders that let you do all sorts of cool things. Need to transpile ES6 code to ES5 for older browsers? Webpack can do that. Want to convert your SCSS into CSS? Webpack’s got you.

5. Sample Webpack Setup for Beginners 🌱

To show you just how easy Webpack is to use, let’s walk through a super basic setup.

First, install Webpack:

npm install webpack webpack-cli --save-dev

Next, create a webpack.config.js file in the root of your project:

const path = require('path');

module.exports = {
  entry: './src/index.js',  // Your main JS file
  output: {
    filename: 'bundle.js',  // The bundled file
    path: path.resolve(__dirname, 'dist')  // Output directory
  },
  mode: 'development',  // Development mode (no minification)
};

In your index.js file:

console.log("Hello from Webpack!");

Now, run Webpack:

npx webpack

That’s it! Webpack bundles your JavaScript into a single bundle.js file, which you can then include in your HTML.

So, there you have it! Webpack might seem a bit intimidating at first, but it’s like the ultimate assistant for managing your web project’s files. It bundles, optimizes, and streamlines everything, saving you tons of headaches in the long run. 🚀

Remember, the more complex your app becomes, the more you’ll appreciate Webpack’s power. And once you get the hang of it, you’ll never want to go back to the old way of doing things.

Happy coding! 😄

————-

Please leave a like/comment if you learned something new today :)

🚀 Top 5 Alternatives to GitHub Copilot

Tanmay Patil — Tue, 01 Oct 2024 04:08:03 +0000

GitHub Copilot has been a game-changer for many developers, but it's not the only AI assistant out there. If you're looking for alternatives to GitHub Copilot for VSCode, here are some fantastic tools you can explore! Whether you're on a budget or just want something that fits your workflow better, I've got you covered. Let's dive into the top alternatives.

1. Tabnine

AI-Powered Code Completion

Tabnine is a powerful AI tool that supports multiple programming languages, providing smart code completions based on context. It's designed to increase productivity by suggesting entire lines or blocks of code.

Pricing:

Free Plan: Yes, includes basic code completions.
Pro Plan: $12/month (per user) with additional features like:
Advanced AI models
Learning from your personal codebase

2. Kite

AI-Powered Python Assistant
⚠️ They are no longer supporting Kite.

Kite offers smart completions, specifically geared towards Python developers. It’s a lightweight, powerful tool that integrates easily with VSCode and helps you code faster with minimal friction.

Pricing:

Free Plan: Yes, completely free for all users.
Pro Features: All features, including multi-line completions and support for various languages, are free.
Kite's official website

3. Intellicode by Microsoft

Enhanced IntelliSense

Built by Microsoft, Intellicode provides context-aware code completions. It uses machine learning to give you better suggestions based on thousands of open-source projects, making it a more personalized experience.

Pricing:

Free Plan: Yes, it's entirely free for VSCode users.
Features: Integrated into VSCode, providing free, intelligent completions ranked by relevance.

4. CodeGeeX

AI-Powered Code Assistant for Multilingual Support

CodeGeeX is another AI-based coding assistant that provides multi-language support and AI-assisted code completion using a large transformer model. It’s great for developers who work with various languages.

Pricing:

Free Plan: Yes, it’s completely free.
Features: Offers multi-language support with no premium tiers.
Check out CodeGeeX

5. Codota

AI-Powered Completion for Java and JavaScript

Codota provides intelligent code completions, with a focus on Java and JavaScript developers. It integrates into VSCode and helps developers by suggesting code that is most relevant to the context.

Pricing:

Free Plan: Yes, includes basic code completions.
Pro Plan: $15/month for more advanced AI models and personal codebase learning.

These are all solid alternatives to GitHub Copilot, each bringing something unique to the table. Whether you want advanced AI-powered completions or simply something more lightweight and free, there's an option for you!

Thanks for reading! Do leave a like/commment if you learned something new today 😄
Happy coding!

Understanding JavaScript Promises: A Comprehensive Guide 🚀

Tanmay Patil — Mon, 30 Sep 2024 11:07:20 +0000

As a web developer, I've often faced the challenge of handling asynchronous operations in JavaScript.
That's where Promises come into play! They offer a powerful way to manage asynchronous tasks.

Let’s dive into the world of promises and explore everything you need to know, point by point! 🌟

1. What is a Promise? 🤔

A promise is an object that represents the eventual completion (or failure) of an asynchronous operation and its resulting value. Think of it as a "promise" that you will get a result in the future.

Example:

let myPromise = new Promise((resolve, reject) => {
    let success = true;

    if (success) {
        resolve("Operation was successful!");
    } else {
        reject("Operation failed.");
    }
});

In this example, we create a promise that resolves if the operation is successful and rejects if it fails.

2. Promise States 📜

A promise has three possible states:

Pending: Initial state; neither fulfilled nor rejected.
Fulfilled: The operation completed successfully.
Rejected: The operation failed.

Example:

let myPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("Data loaded successfully!");
    }, 2000);
});

console.log(myPromise); // Initially in 'pending' state

After 2 seconds, the promise transitions to a fulfilled state with the message “Data loaded successfully!”.

3. Using `then()` and `catch()` Methods 📈

Promises allow chaining through the then() method, which is called when the promise is fulfilled. The catch() method is used to handle any errors if the promise is rejected.

Example:

myPromise
    .then(result => {
        console.log(result); // "Data loaded successfully!"
    })
    .catch(error => {
        console.error(error);
    });

This code logs the result if the promise is fulfilled or catches any errors if it’s rejected.

4. Chaining Promises 🔗

One of the coolest features of promises is that you can chain them together. Each then() returns a new promise, allowing for a sequence of asynchronous operations.

Example:

myPromise
    .then(result => {
        console.log(result);
        return "Next operation!";
    })
    .then(nextResult => {
        console.log(nextResult); // "Next operation!"
    })
    .catch(error => {
        console.error(error);
    });

Here, we chain two then() methods to process results sequentially.

5. Promise.all() and Promise.race() ⚡

Sometimes, you need to handle multiple promises at once. Promise.all() takes an array of promises and returns a single promise that resolves when all promises have resolved or rejects if any promise is rejected.

Example:

let promise1 = Promise.resolve("Result 1");
let promise2 = new Promise((resolve) => {
    setTimeout(() => resolve("Result 2"), 1000);
});
let promise3 = new Promise((_, reject) => {
    setTimeout(() => reject("Failed!"), 500);
});

Promise.all([promise1, promise2, promise3])
    .then(results => {
        console.log(results); // This won't execute due to promise3 rejection
    })
    .catch(error => {
        console.error(error); // "Failed!"
    });

In this example, Promise.all() rejects as soon as one promise fails.

On the other hand, Promise.race() resolves or rejects as soon as one of the promises in the array settles.

Example:

Promise.race([promise1, promise2])
    .then(result => {
        console.log(result); // "Result 1"
    });

Here, Promise.race() resolves with the first settled promise.

6. Error Handling in Promises 🔍

It's essential to handle errors properly when working with promises. You can catch errors at the end of a promise chain using catch(), but you can also handle them within the then() using a second argument.

Example:

myPromise
    .then(result => {
        throw new Error("Something went wrong!"); // Simulating an error
    }, error => {
        console.error("Caught in then:", error);
    })
    .catch(error => {
        console.error("Caught in catch:", error);
    });

In this example, we handle an error within the then() method and then catch any remaining errors.

7. Async/Await: Syntactic Sugar for Promises ☕

With the introduction of async/await, working with promises has become even simpler. You can write asynchronous code that looks synchronous, improving readability.

Example:

const loadData = async () => {
    try {
        const result = await myPromise;
        console.log(result);
    } catch (error) {
        console.error(error);
    }
};

loadData(); // "Data loaded successfully!"

Using async/await allows for cleaner code, making it easier to read and understand.

Quick Quiz: Test Your Promise Knowledge! 📝

What are the three states of a promise?
What method do you use to handle successful promise completion?
How can you run multiple promises in parallel?
What does Promise.race() do?
How can you write asynchronous code that looks synchronous?

That's a wrap on JavaScript promises! With these concepts, you can effectively manage asynchronous operations and improve your coding experience. Promises have transformed how we handle async tasks, and I hope this guide helps you navigate their powerful features! Happy coding! 😊

How AI became my secret weapon for faster learning 🧠⚡️

Tanmay Patil — Mon, 30 Sep 2024 09:58:16 +0000

Alright, let me share a little secret: AI has seriously changed how I learn. It’s like having a super-efficient assistant that helps me get through tough concepts way faster. I've been using AI in all kinds of ways, and it’s made learning feel less like a chore and more like an adventure. Here’s how I do it (and you can too)! 🚀

1. Get Quick Summaries 📚✨

I used to spend hours going through long articles and blog posts. Now? I just ask AI to summarize stuff for me. It’s amazing how much time you save.

How it helped:

When I was learning JavaScript frameworks, instead of reading a dozen articles, I’d just ask ChatGPT to summarize the key points. In minutes, I had everything I needed!

Example:

“Hey, ChatGPT, can you summarize this blog on JavaScript best practices for me?”

2. Personalized Quizzes = Fun Learning 📝

Studying used to feel dull, but I turned it into a game. I started using AI to create quizzes for myself, and honestly, it’s so much more fun.

How it helped:

When I was learning React, I’d ask AI to quiz me. If I got something wrong, I’d go back and revisit that part. It really reinforced what I was learning.

Example:

“Create a 5-question quiz for me about React.js fundamentals.”

3. Learn in Small Chunks 🍬

Ever felt overwhelmed by all the things you need to learn? Same here. So, I started asking AI to break concepts down into smaller, bite-sized pieces.

How it helped:

When I first tried understanding closures in JavaScript, I couldn’t wrap my head around it. AI gave me a super simple explanation, and it finally clicked!

Example:

“Can you explain closures in JavaScript in simple terms?”

4. Instant Problem Solver 🛠️🤔

You know when you’re stuck on something and can’t find the answer on Google? That’s when I turn to AI. It’s like having an expert available 24/7.

How it helped:

I was having trouble with recursion (ugh, right?), and every tutorial confused me more. I asked AI to explain it, and suddenly, it made sense.

Example:

“I don’t get recursion. Can you explain it with a simple example?”

5. AI = My Personal Study Planner 📅💡

Juggling a full-time job and learning new skills is hard. But AI helps me organize my learning schedule so I don’t get overwhelmed.

How it helped:

When I was trying to learn TypeScript, I didn’t know where to start. I asked AI to make me a 4-week study plan, and it kept me focused and on track!

Example:

“Help me create a 4-week plan to learn TypeScript, with daily topics.”

6. Generate Code on the Fly 💻

Sometimes, I just need a quick code example, and AI gives me exactly what I’m looking for. This has saved me so much time.

How it helped:

While working on a project, I needed an example of how promises work. Instead of hunting for one, I asked AI, and boom—there it was.

Example:

“Can you give me an example of a JavaScript promise?”

7. Get Feedback Instantly 🧐✅

I don’t always have someone to review my work, so I started asking AI for feedback. It’s like having a tutor ready to help whenever I need it.

How it helped:

Once, I was trying to optimize a Python function. AI pointed out how I could improve it, and honestly, I wouldn’t have caught that on my own!

Example:

“Can you check if my Python function is efficient? Any improvements?”

8. Teach AI What You’ve Learned 🧠📖

One of the best ways to learn is by teaching. Sometimes I’ll explain a concept to AI, just to see if I’m on the right track. It helps me lock in my knowledge.

How it helped:

I explained HTTP requests to AI and asked if I got it right. Not only did it confirm, but it also gave me extra tips. It’s a win-win.

Example:

“Let me explain how HTTP requests work. Tell me if I got it right!”

9. Stay Up-to-Date with AI 🌐📰

Keeping up with tech trends is tough. But now, I just ask AI to give me daily updates, so I always feel like I’m in the loop.

How it helped:

I asked AI about new features in JavaScript ES2023, and it gave me a concise overview. I was able to stay current without reading long docs!

Example:

“What are the latest updates in JavaScript ES2023?”

10. Beat Procrastination ⏳💪

Procrastination is my enemy! AI helps keep me accountable by reminding me of tasks or even just giving me a little nudge to stay productive.

How it helped:

When I kept putting off learning Python, AI gently reminded me about my study plan, and it actually worked! I’m back on track now.

Example:

“Remind me to study Python for 30 minutes tomorrow!”

So there you go! 🎉 These are some of the ways I’ve been using AI to learn faster, smarter, and without the usual stress. Give it a try—you might just be surprised at how much it can help!

📈 10 Ways ChatGPT Can Supercharge Your Productivity as a Developer

Tanmay Patil — Mon, 30 Sep 2024 07:08:56 +0000

In the hustle and bustle of software development, every little productivity hack counts! Enter ChatGPT—your friendly AI assistant ready to help you code smarter, debug faster, and lighten your workload. Here’s how to harness its power without feeling overwhelmed.

1. Code Generation: Your Personal Coding Buddy 🤖

Stuck on a repetitive piece of code? Just ask ChatGPT!

Example:

“Can you help me write a JavaScript function to fetch data from an API?”

Response:


async function fetchData(url) {
    try {
        const response = await fetch(url);
        if (!response.ok) {
            throw new Error(`HTTP error! Status: ${response.status}`);
        }
        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching data:', error);
    }
}

Boom! You’ve got a ready-to-use function in seconds.

2. Debugging: Your AI Detective 🕵️‍♂️

Debugging can feel like a mystery novel—frustrating and sometimes confusing. Describe the problem to ChatGPT, and it can help you figure it out!

Example:
“I’m getting a ‘TypeError: undefined is not a function.’ Here’s my code…”

ChatGPT can pinpoint where things might be going wrong, making you feel like a coding detective.

3. Documentation: Your Writing Assistant ✍️

Documentation doesn’t have to be dull. Use ChatGPT to draft clear explanations for your code!

Example:

“Help me write documentation for a sorting function.”

Response:

### sortArray

Sorts an array of numbers in ascending order.

**Parameters:**
- `arr`: An array of numbers.

**Returns:**
- A sorted array.

**Example:**
--javascript
sortArray([5, 3, 8, 1]); // [1, 3, 5, 8]
---

6. Refactoring Code: Your AI Code Review Partner

Refactoring can feel tedious, but ChatGPT can help suggest improvements to make your code cleaner and more efficient.

Example:

“Can you help me refactor this function for better readability?”

Response:

ChatGPT might suggest changes like breaking the function into smaller pieces, using descriptive variable names, or simplifying complex logic, helping you keep your codebase tidy.

7. Learning from Errors: Your Teaching Assistant 📚

Staying updated on best practices can be a challenge. You can ask ChatGPT about the latest trends and techniques in software development.

Example:

“What are some best practices for writing clean code?”

Response:

Use meaningful names for variables and functions.
Keep functions small and focused.
Write comments to explain why (not just what) your code does.
These best practices can help you write maintainable code and improve your overall coding skills!

8. Testing Assistance: Your QA Ally

Writing tests can sometimes feel like a chore, but ChatGPT can assist in generating test cases for your code.

Example:

“Can you help me write unit tests for this function?”

Response:

ChatGPT can provide you with a set of unit tests in your preferred testing framework, helping ensure your code works as intended.


describe('fetchData', () => {
    it('should fetch data successfully', async () => {
        const data = await fetchData('https://api.example.com/data');
        expect(data).toBeDefined();
    });

    it('should handle errors gracefully', async () => {
        const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
        await fetchData('https://api.example.com/error');
        expect(consoleSpy).toHaveBeenCalled();
        consoleSpy.mockRestore();
    });
});

9. Learning from Errors: Your Teaching Assistant

When you encounter an error, you can turn to ChatGPT to not only help fix it but also explain the underlying problem.

Example:

“I’m getting an ‘undefined variable’ error. What does it mean?”

Response:

ChatGPT can explain that this error typically occurs when you try to access a variable that hasn’t been declared or initialized, helping you understand and learn from your mistakes.

10. Time Management: Your Scheduling Wizard ⏳

Balancing multiple projects can be tricky. ChatGPT can help you prioritize tasks and manage your time effectively.

Example:

“I have these tasks to complete: feature A, bug fix B, and a code review. What should I prioritize?”

Response:

ChatGPT might suggest prioritizing based on deadlines, importance, or complexity, helping you create a more organized work schedule.

🦕 What is Deno?

Tanmay Patil — Wed, 25 Sep 2024 04:48:30 +0000

This article is a great starting point for beginners to Deno.

Covers:

About Deno

Key Features

Example Code

Deno vs. Node.js

Why Use Deno?

Learning Resources

About Deno

Deno is a modern, secure JavaScript and TypeScript runtime, created by Ryan Dahl, the original creator of Node.js. It addresses some of the design shortcomings in Node.js while providing better security and more modern features. Deno was introduced as an alternative to Node.js, with a focus on modern development practices and security.

Key Features of Deno:

🔐 Security by Default:

Unlike Node.js, Deno is secure by default. It runs scripts in a sandboxed environment and restricts access to the file system, network, environment variables, and other resources unless explicitly allowed with command-line flags (e.g., --allow-read, --allow-net).

📦 Supports TypeScript Out-of-the-Box:

Deno has built-in TypeScript support without the need for configuration or a separate compilation step. It directly interprets .ts files, making TypeScript development easier and more seamless.

🤯 No `node_modules`:

Yup you heard it right!
Deno does not use a node_modules folder or a package manager like npm. Instead, it uses standard URLs to import third-party modules. This makes dependency management simpler and reduces the complexity around dependency trees.

import { serve } from "https://deno.land/std@0.105.0/http/server.ts";

🛠️ Built-In Tooling:

Deno comes with several built-in tools, such as a test runner (deno test), a code formatter (deno fmt), a linter (deno lint), and more. This reduces the need for additional tooling.

📀 Single Executable:

Deno is distributed as a single executable binary, making installation simpler across various platforms.

Standard Modules:

Deno provides a standard library of modules hosted on its official platform (deno.land/std). These modules follow consistent and predictable standards for building applications.

🫱🏼‍🫲🏻 Promise-Based APIs:

Many of Deno's APIs are modern and built around promises, eliminating older callback-based patterns that are still prevalent in Node.js.

⚙️ ES Modules by Default:

Deno uses ECMAScript (ES) modules as the default module system, instead of CommonJS used by Node.js. This makes it compatible with modern JavaScript standards and avoids the require and module.exports syntax used in Node.js.

Example Deno Code:

import { serve } from "https://deno.land/std@0.105.0/http/server.ts";

const server = serve({ port: 8000 });
console.log("HTTP server is running on http://localhost:8000");

for await (const req of server) {
  req.respond({ body: "Hello, Deno!" });
}

Differences Between Deno and Node.js:

Security: Deno is sandboxed by default, requiring explicit permission for network, file system, etc., while Node.js runs without such restrictions.

Module System: Deno uses ES modules and URLs for imports, while Node.js uses CommonJS and a node_modules system.

TypeScript Support: Deno has native TypeScript support without configuration, whereas in Node.js, you need to set up TypeScript with tools like ts-node or babel.

No package.json or npm: Deno does not rely on a package manager, and you import modules via URLs instead of a centralized package repository like npm.

Why Use Deno?

Security: If your project requires a secure-by-default environment.

Modern Development: For developers who want to take advantage of TypeScript out-of-the-box, modern JavaScript standards, and native ES module support.

Simpler Tooling: Built-in testing, linting, and formatting reduce the need for external packages.

Let me know what part of this topic would you like me to cover in-depth.

Here are some valuable resources to help you learn more about Deno, along with their full links:

Deno's Official Documentation
A comprehensive guide covering Deno's APIs, setup, tutorials, and examples.
https://deno.land/manual

Deno by Example
A collection of practical, runnable examples that teach you Deno’s important features.
https://examples.deno.land/

Fresh Framework
A modern web framework for Deno designed for speed and simplicity.
https://fresh.deno.dev/

Deno Deploy
Learn how to deploy Deno applications using Deno's serverless hosting platform.
https://deno.com/deploy

Deno KV
Information on building stateful applications using Deno KV, a database system built for Deno.
https://deno.com/blog/kv-release

Better Stack Guide: Deno Overview for Node.js Users
A guide specifically aimed at Node.js developers transitioning to Deno, covering key differences and features.
https://betterstack.com/community/guides/deno-overview

These links provide the essential resources to dive into Deno development!

Last but not the least, do support with a like and share if at all you got to learn something new from this. 🫶🏼

Forem: Tanmay Patil

Why You Should Hang Around People Doing Better Than You 💪🏽

How Surrounding Yourself with the Right People Helped Me 🌟

1. At Work: Pushing My Limits

2. At Home: Family Dynamics

3. Social Life: Uplifting vs. Draining People

4. In the Gym: You Get What You Surround Yourself With

The Flip Side: The Danger of Negative People ⚠️

The Investment That Compounds Over Time 📈

How It Shaped My Character and Intellectual Conversations 🧠

Final Thoughts: Find Opportunities in Problems 🌱

How I Utilise 3 Hours of My Daily Commute Productively 🚗🎧

"Growth isn’t just about what you do when you’re at your desk; it’s about how you leverage every second you have to improve yourself."

My Daily Commute: The 3-Hour Opportunity 🚗

Turning Traffic Time Into Learning Time 🎧📚

1. Business & Tech Podcasts 🧠💼

2. Audiobooks 📖🎧

3. CTO Interviews: Learn System Design 👨‍💻🔧

4. Rotating Podcast Categories 🔄🎙️

The Impact: Numbers Speak 📈

Conclusion: Leverage Every Opportunity 🚀

Simplified: Javascript V8 engine ✨

How Does the V8 Engine Really Work?

What Exactly is the V8 Engine? 🧐

Step-by-Step: How V8 Works Under the Hood 🔧

1. Parsing: Understanding Your Code 📜

Example:

2. Interpreter (Ignition): Quickly Running Your Code 🏃‍♂️

3. Profiling: Watching Your Code in Action 👀

4. Optimization (TurboFan): Making it Super Fast 🚗💨

Example:

5. Garbage Collection: Cleaning Up the Mess 🗑️

What Makes V8 Special? 🌟

1. JIT Compilation ⚡

2. Efficient Memory Management 📉

3. Native Support for Modern JavaScript 💡

Let’s Recap with an Example 🌐

The Future of V8 🔮

Final Quiz Time! 📝

💡 How JavaScript Works Under the Hood: A Fun Dive Into the Magic ✨

1. JavaScript Is Not Magic (But Close Enough!) 🪄

2. Enter the JavaScript Engine: The Super Brain 🧠

Chrome’s JS Engine: V8 🚗

3. What About Optimization? 🚀

Example:

4. The Event Loop: JavaScript's Secret Weapon 🔄

Example:

5. From JavaScript to the Browser: The Big Picture 🌐

Wrapping Up: JavaScript—It’s Smarter Than You Think 🧠

Webpack Simplified: A Beginner’s Guide to Understanding Webpack 🛠️

1. What is Webpack? 🤔

2. Why Do We Need Webpack? 🛠️

3. How Did Things Work Before Webpack? 🕰️

4. Benefits of Webpack 🚀

1. Bundling All Your Files Together 📦

2. Handles Dependencies Automatically 🔗

3. Optimizes Your Code for Performance ⚡

4. Hot Module Replacement (HMR) 🔥

5. Extensible with Plugins & Loaders 🛠️

5. Sample Webpack Setup for Beginners 🌱

🚀 Top 5 Alternatives to GitHub Copilot

1. Tabnine

Pricing:

2. Kite

Pricing:

3. Intellicode by Microsoft

Pricing:

4. CodeGeeX

Pricing:

5. Codota

Pricing:

Understanding JavaScript Promises: A Comprehensive Guide 🚀

1. What is a Promise? 🤔

2. Promise States 📜

3. Using then() and catch() Methods 📈

4. Chaining Promises 🔗

5. Promise.all() and Promise.race() ⚡

6. Error Handling in Promises 🔍

7. Async/Await: Syntactic Sugar for Promises ☕

Quick Quiz: Test Your Promise Knowledge! 📝

3. Using `then()` and `catch()` Methods 📈

🤯 No `node_modules`: