Forem: Tejas

How the Hell C++ Templates Work ?

Tejas — Mon, 04 Dec 2023 16:47:51 +0000

Hey there, Welcome to a guide on C++ templates! 🎉 In this article, we will explore the ins and outs of using C++ templates and delve into the reasons why they are powerful for developers. Whether you are a seasoned programmer or starting your coding journey, templates in C++ are essential for writing efficient and reusable code. Let's roll up our sleeves and dive right in! 💪💻

C++ templates are a powerful feature that allows programmers to define generic types and functions. They provide a way to write code that can be used with different data types without sacrificing performance or code readability. Templates in C++ essentially enable us to write code once and use it with multiple types, saving us from writing repetitive code for each specific type. 🔧✨

Function Templates

Function templates are one aspect of C++ templates that make them incredibly useful. Imagine you need to write a function that swaps the values of two variables, but you want the flexibility to swap integers, floating-point numbers, or even custom data types without writing separate swap functions for each. Here's where function templates come to the rescue. 🔄🔀

Let's take a look at a simple example of a function template that swaps two values:

template<typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

In the code snippet above, the typename T denotes a placeholder type that can be substituted with any desired type. This function template can be used with various data types, such as int, float, or even user-defined classes. The compiler automatically generates the appropriate code for each type, eliminating the need to write multiple swap functions. 🤝🔧

Class Templates

While function templates are incredibly powerful, C++ templates go even further with class templates. Class templates allow us to define classes that are generic and can work seamlessly with different types. This gives us the ability to write reusable code that can be applied to a wide range of scenarios. 📦💡

Let's consider a simple example of a class template called Stack, which represents a stack data structure:

template<typename T>
class Stack {
private:
    std::vector<T> elements;
public:
    void push(const T& value) {
        elements.push_back(value);
    }

    void pop() {
        if (!elements.empty()) {
            elements.pop_back();
        }
    }

    T top() const {
        if (!elements.empty()) {
            return elements.back();
        }
        throw std::runtime_error("Stack is empty!");
    }
}

In the code snippet above, we define a template class called Stack that can be instantiated with any data type. This flexibility allows us to create stacks of integers, strings, or even complex user-defined objects. The class methods are defined in the same way as for any regular class, but they can work seamlessly with different types. 📚🔧

Why Use C++ Templates? ❓
Now that we have a good understanding of what C++ templates are, let's explore some compelling reasons why you would want to use them in your code.

Code Reusability ♻️
One of the primary advantages of using C++ templates is code reusability. Templates enable us to write generic code that can adapt to different data types. This eliminates the need to write repetitive code for each specific type, resulting in more concise and maintainable codebases. By leveraging templates, you can achieve a significant reduction in code duplication and increase overall development productivity. 🔄🔀💼

Performance Optimization ⚡
Contrary to popular belief, C++ templates do not incur runtime overhead. The compiler generates specialized versions of the template code for each data type used. This process, known as template instantiation, eliminates the need for runtime type checks and ensures optimal performance as if you were writing dedicated code for each type individually. Templates effectively bridge the gap between code flexibility and performance, making them an excellent choice for performance-critical applications. 🚀🔧

Type Safety 🔒
Another significant benefit of C++ templates is the inherent type safety they offer. With templates, the compiler performs rigorous type checking at compile-time, preventing type-related errors and promoting robust code. Any mismatches or inconsistencies in types are caught during compilation, eliminating the risk of runtime errors due to type mismatches. Templates enforce strict type correctness, resulting in highly reliable and bug-free code. 🧰✅

Conclusion ✅
C++ templates are a powerful tool in a programmer's arsenal. They allow us to write generic code that can adapt to various data types while maintaining high performance and type safety. Function templates and class templates provide the flexibility to create reusable code that saves us from the redundant task of writing type-specific code. By leveraging C++ templates, you can enhance code reusability, optimize performance, and ensure type safety in your programs. So go ahead and harness the power of C++ templates in your projects to unlock a new level of efficiency and elegance in your code. Happy coding! 🚀💻😊

Generating functions in Javascript

Tejas — Sat, 25 Nov 2023 18:37:11 +0000

Lazy Evaluation

What if I told you that you can be lazy and productive at the same time? In the world of programming, lazy evaluation is a technique that allows you to defer the evaluation of an expression until it is absolutely necessary. In the context of Javascript, this means that you can delay the execution of a function until the result is needed.

Lazy evaluation can be extremely useful in scenarios where you are dealing with complex and resource-intensive computations. By deferring the execution of a function until it is actually required, you can optimize the performance of your code and avoid unnecessary calculations.

But how does lazy evaluation actually work in Javascript? Well, it all comes down to the concept of generating functions. A generating function is a special type of function that returns an iterator object instead of a concrete value. This iterator can then be used to generate values on demand, only when they are needed.

Let's take a closer look at how lazy evaluation using generating functions can be implemented in Javascript.

Using generators in Javascript

In Javascript, generators provide an elegant solution for implementing lazy evaluation. Generators are functions that can be paused and resumed, allowing you to control the flow of execution. They are defined using the function* syntax and yield values using the yield keyword.

Here is a simple example of a generating function that generates an infinite sequence of numbers:

function* generateNumbers() {
  let i = 0;
  while (true) {
    yield i++;
  }
}

Notice how the generateNumbers function is defined using the function* syntax. Inside the function, we use a while loop to generate an infinite sequence of numbers. The yield keyword is used to yield the next value in the sequence.

Lazy evaluation in action

Now that we have our generating function, let's see how we can use it to implement lazy evaluation.

const numbers = generateNumbers();

console.log(numbers.next().value); // 0
console.log(numbers.next().value); // 1
console.log(numbers.next().value); // 2
// and so on...

In this example, we create an instance of the generateNumbers generator by calling the function. We can then use the next() method to retrieve the next value in the sequence. Since the sequence is infinite, we can keep calling next() indefinitely to generate as many numbers as we need.

By using a generating function, we can ensure that the numbers are only generated when we actually need them. This can be especially useful when dealing with large datasets or expensive computations.

Asynchronous Programming

In the fast-paced world of web development, asynchronous programming is a crucial technique for building responsive and efficient applications. Asynchronous programming allows you to execute multiple tasks concurrently, without blocking the main thread.

In Javascript, asynchronous programming is commonly achieved using callbacks, promises, and async/await syntax. These techniques allow you to perform time-consuming operations, such as making API requests or accessing a database, without blocking the execution of the rest of your code.

But how does asynchronous programming relate to generating functions? Well, generating functions can be a powerful tool for managing asynchronous operations in an elegant and intuitive way.

Asynchronous generators

In Javascript, asynchronous generators combine the power of generating functions with the flexibility of asynchronous programming. An asynchronous generator is a function that returns an asynchronous iterator object, allowing you to generate values asynchronously.

Here is an example of an asynchronous generating function that fetches data from an API:

async function* fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();

    for (const item of data) {
      yield item;
    }
  } catch (error) {
    console.error('Failed to fetch data:', error);
  }
}

In this example, the fetchData function uses the async function* syntax to define an asynchronous generating function. Inside the function, we use the await keyword to fetch data from an API and yield each item asynchronously.

Managing asynchronous tasks with generators

By using asynchronous generators, we can simplify the management of asynchronous tasks in our code. We can use the for-await-of loop to iterate over the values generated by an asynchronous generator.

(async () => {
  const dataGenerator = fetchData();

  for await (const item of dataGenerator) {
    console.log(item);
  }
})();

In this example, we create an instance of the fetchData asynchronous generator and iterate over the values using the for-await-of loop. The loop automatically awaits each value before running the next iteration, ensuring that the asynchronous tasks are executed in the correct order.

Asynchronous generators provide a convenient way to handle asynchronous operations in a sequential and readable manner. They simplify the complexity of managing callbacks or chaining promises, making our code more maintainable and easier to understand.

Infinite Sequences

From the concept of lazy evaluation to the power of asynchronous programming, generating functions have proven to be a versatile tool in Javascript. Another fascinating aspect of generating functions is their ability to produce infinite sequences.

In mathematics, an infinite sequence is a sequence that continues indefinitely without an endpoint. In the context of generating functions, we can create infinite sequences of values using a combination of lazy evaluation and recursion.

Let's explore how we can implement infinite sequences using generating functions in Javascript.

Fibonacci sequence

One of the most famous examples of an infinite sequence is the Fibonacci sequence. The Fibonacci sequence starts with 0 and 1, and each subsequent number is the sum of the two preceding ones.

function* fibonacci() {
  let a = 0, b = 1;

  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

In this example, the fibonacci generating function uses a while loop to yield the next number in the Fibonacci sequence infinitely. The values are generated lazily, ensuring that the computations are only performed when necessary.

Using infinite sequences

Now that we have our infinite sequence of Fibonacci numbers, let's see how we can use it in our code.

const sequence = fibonacci();

console.log(sequence.next().value); // 0
console.log(sequence.next().value); // 1
console.log(sequence.next().value); // 1
console.log(sequence.next().value); // 2
console.log(sequence.next().value); // 3
// and so on...

In this example, we create an instance of the fibonacci generator and use the next() method to retrieve the next value in the sequence. As with other generating functions, the values are generated on-demand, allowing us to work with infinite sequences efficiently.

Infinite sequences can be a powerful tool in various scenarios, such as generating random numbers, simulating complex systems, or even creating an endless stream of jokes (if you're feeling particularly quirky). The possibilities are limited only by your imagination!

Conclusion

Generating functions in Javascript offer a unique approach to lazy evaluation, asynchronous programming, and infinite sequences. By harnessing the power of generating functions, you can optimize performance, simplify asynchronous operations, and create fascinating endless streams of values.

Whether you need to generate values on-demand, handle asynchronous tasks gracefully, or explore the infinite realm of mathematical sequences, generating functions have got you covered. So go ahead, embrace the magic of generating functions in Javascript, and let your code reach new heights of elegance and efficiency!

Git cheatsheet

Tejas — Tue, 11 Jul 2023 17:11:45 +0000

Git Cheatsheets and Tricks

Git is a powerful and versatile version control system that has become an essential tool for software development teams and individual developers alike. In this article, we'll cover some Git cheatsheets and tricks that will help you improve your Git skills.

Git Cheatsheets

A Git cheatsheet is a quick reference guide that summarizes the most commonly used Git commands and their usage. Here are some common Git commands that you might find on a Git cheatsheet:

Initialize a repository

git init # Initialize a new repository

Clone a repository

git clone <repository_url> # Clone an existing repository

Working with branches

git branch                  # List all branches
git branch <branch_name>    # Create a new branch
git checkout <branch_name>  # Switch to a branch
git merge <branch_name>     # Merge a branch into the current branch
git branch -d <branch_name> # Delete a branch

Commiting changes

git status               # Show the status of your changes
git add <file_name>      # Stage changes for commit
git add .                # Stage all changes for commit
git commit -m "message"  # Commit staged changes with a message

pulling and pushing changes

git remote add origin <repository_url>  # Add a remote repository
git push -u origin <branch_name>        # Push changes to a remote repository
git pull origin <branch_name>           # Pull changes from a remote repository

View commit history and differences

git log             # Show commit history
git diff            # Show differences between current changes and previous commit
git diff <commit>   # Show differences between current changes and a specific commit

Undoing changes

git reset <file_name>    # Unstage changes for a specific file
git reset                # Unstage all changes
git checkout <file_name> # Discard changes for a specific file
git checkout .           # Discard all changes
git revert <commit>      # Undo a commit by creating a new commit with the opposite changes

stash

git stash        # Stash changes
git stash list   # List all stashes
git stash apply  # Apply the most recent stash
git stash drop   # Drop the most recent stash

My Programming journey

Tejas — Mon, 01 May 2023 16:35:01 +0000

Alright so here you are welcome to this blog where I tell you what I had been doing for past few years. In this blog, I will be sharing my experiences, challenges, and successes as I navigate the vast and ever-evolving world of programming. Through this blog, I hope to connect with like-minded individuals and inspire others to pursue their own programming journeys. So, sit back, grab a cup of coffee, and join me on this exciting adventure!

Let's see how it all started,
It was a dark and stormy night, and I was procrastinating on YouTube, watching funny cat videos when, out of nowhere, I stumbled upon a channel called Brackeys. Little did I know that this was going to change my life forever. I downloaded Unity and started following Brackeys' tutorials, feeling like a pro at first, but then slowly realizing that I had no idea what I was doing.

Little did I know I was stuck in tutorial hell for two whole F**king years!!

1st PU

I gave up on unity and started trying everything. Literally everything . From Python to Rust, from Django to Flask, and from silly websites to Discord bots. I even dabbled in competitive programming, failing over and over again.

🔐 down

But guess where I landed? In the land of PHP! Yup, you heard that right. I saw a YouTube recommendation from Yahoo baba and I watched a PHP playlist by Yahoo Baba and spent half of my lockdown building a social media app called Orkut. Why Orkut, you ask? Well, I liked the name, okay? It was vanilla PHP, but I did manage to add authentication and basic CRUD operations, which I called "posts".

In the second half of lockdown, I moved on to Laravel and Vue.js, and that's when I built Waddle , a monolithic application. This was the first project I did without relying too much on tutorials, and let's just say that I finally got out of tutorial hell.

College

1st year

I went to college and met a Legend . Everyone might either be jack of all trades and master of none or master of one but never both . But this guy is master of all trades. With him on my side we completed many cool projects together. It sure does help when your friends have same interest as you.

There is always a bigger fish

This is markdown previewer built with alpine js

weather app

After all these projects I thought I could build Waddle even better So I built Guild with nextjs on frontend and Laravel on backend. I also discovered Tailwind around this time.

As a responsible human being, I also tried my best to pass in college. It wasn't easy though, especially when I had to balance my coursework with my programming projects.

One time, I stayed up all night to finish a coding project, and by the time I submitted it, the sun was already up. I looked like a zombie with dark circles under my eyes, and my teacher probably thought I was pulling an all-nighter partying. Little did he know that I was just having a coding marathon with myself.

2nd year

We collaborated in a team of 3 members to develop a project for a specific company and designed and implemented APIs to create Realtime location-based system using leafletjs resulting in winning 1st place in the competition showcasing project to company
Hackathon

yeah that guy on the right is me. We spent around 30 hours without sleep just working on project. Our hard work paid off and more importantly we got lots of experience and knowledge on team work

I started hopping into frontend Frontend mentor was a major help to me without which I wouldn't have gotten better at frontend.
actually most of my small projects can be found here in UILib
Here are some other things built thanks to frontend mentor

rock paper scissors

space tourism

I know I still have a long way to go before I become the programming wizard I aspire to be. I'm still nowhere near where I want to be.

So, there you have it, folks. My programming journey that started with me watching YouTube videos and ended up with me building cool projects.

Hope you enjoyed the ride as much as I did!