DEV Community: Aamir

What is Amortized Time Complexity Analysis

Aamir — Thu, 07 Dec 2023 06:27:41 +0000

When designing and working with algorithms, our primary concern often revolves around the worst-case performance. This factor can significantly impact our application's overall performance.
However, there are instances when these worst-case time complexities might be somewhat deceiving.

Consider the example of a widely used data structure known as a DynamicArray. Specifically, in Java, we have the ArrayList, and in C++, the equivalent is the vector datatype – both exemplifying dynamic arrays. Dynamic Arrays are valuable because, under the hood, they store data sequentially, allowing for swift sequential data access. Despite this sequential storage, dynamic arrays perform dynamic resize operations when the capacity is reached, making things easier for us, because we do not have to worry about resizing the array ourselves, or memory allocations and deallocations. However, these operations come at a cost in terms of CPU cycles.

Analyzing the Worst Case Time Complexity of the Insert Operation for Dynamic Arrays

When scrutinizing the worst-case time complexity of an insert operation for dynamic arrays, it turns out to be O(N + M) where N is the number of elements inserted and M is the number of elements copied into a new memory buffer. This is due to the allocation of a new block of memory (typically double the size of the previous block), and copying all data from the old block to the new one. This doubling of memory and the subsequent copy operations are computationally expensive. Let's examine an example of how the insertion of eight elements would unfold in a dynamic array.

If we can somewhat estimate the size requirements of our vector, reserving a block of memory during initialization can significantly improve the efficiency. This proactive approach minimizes the need for costly memory copy operations associated with resizing.

back to the time complexity analysis...

In this small example, the frequency of O(1) insert operations is considerably higher than the O(N)+1 operations for memory copying to a new block. In situations where there is an imbalance in the frequency of different operations, with an expensive, infrequent operation occurring alongside a cheap, frequently occurring operation, it is better to perform an Amortized Performance Analysis to obtain a more accurate performance assessment.

Amortized Time Complexity Analysis

To comprehend the amortized time complexity, we need to properly account for the frequent O(1) insert operations alongside the infrequent but compute-intensive O(N)+1 insert operations and divide the total cost of insertions over N insertions. This yields the average time complexity of the insert operation, which provides a more accurate representation than the pessimistic O(N+M) worst-case time complexity.

Assuming we insert N elements with constant insertion time, the time complexity for this operation would be O(N).
Examining the above diagram of insert operations, we can observe that the doubling of the array operation takes place roughly O(logN) times.

Considering the above two facts, let's compute the amortized time complexity.

This result is powerful as it indicates that despite some operations being expensive (e.g., when resizing is required), the average cost of operations remains constant when spread out over a large number of operations.

In summary, Amortized Time Complexity Analysis emerges as a valuable tool for assessing algorithm performance. It excels in scenarios where frequent, low-cost operations coexist with occasional, compute-intensive ones. This analytical approach offers a nuanced understanding, allowing us to gauge performance more accurately and make informed decisions in algorithm design.

Somewhere, something incredible is waiting to be known. - Carl Sagan

So What is a GIL In Python ? Multiprocessing in Python.

Aamir — Sat, 24 Sep 2022 09:47:28 +0000

No matter who you are or where you come from, one thing we can all agree upon is that Finding Nemo is an absolute masterpiece (10/10). if you have not watched it yet, then I would highly recommend watching it right away, of course after going through this article :)

As you might recall, Finding Nemo had a character called GILL (Moorish Idol fish). In the movie, GILL had a leadership role inside his fish tank. GILL made all the important decisions and planned the future for the betterment of his fish tank.

The GIL (Global Interpreter Lock) that we are discussing today, also has a very similar role in Python, a mechanism that has been developed around the memory management system of Python. GIL keeps the stuff (in this case avoiding memory leaks and race conditions) in order, and makes a lot of things simpler and cleaner. However, just like all that glitters are not gold, GIL also has some problems especially if want to write something which is compute-intensive (CPU-bound).

Let's dive a little deep (Python's GIL Mechanism)

In programming languages, if you want to do compute-intensive work, the first solution which pops up in your head is Threads. In python, while you can utilize the threading module, it is only suitable if the task that you are performing is I/O bound (reading and writing to disk, performing network operations). This is because GIL ( Global Interpreter Lock) only allows one thread to be in the state of execution at any given time. So, if your machine has let's say 8 cores, then you can not take advantage of all the cores for computation.

At this point, you might be asking yourself, why GIL has been designed like this. Python utilizes a reference counting mechanism to manage memory for you, this means if the reference count of a variable reaches zero, then it is automatically cleaned up. In many ways, this makes the life of a developer so much simpler.

# Variable name is cleaned up immediately after the 
# execution of function scope, as reference count reaches zero
def the_coolest_function_ever():
   name = "Aamir"


# ==== Let's take a slightly involved example =====


# In the following function planet_name will not be 
# cleaned, as at the end of the function scope the 
# reference count of planet_name will be greater than 0
def boot_planet(planet_name):
   print("Booting....")

   # planet_name Ref-count => 3
   print(planet_name)



def main():

   # planet_name Ref-count => 1
   planet_name = "Mars"

   # planet_name Ref-count => 2
   boot_planet(planet_name)

It can be seen in the above code snippet, that the reference counting system made things so much simpler when it comes to memory management, allowing you the developer to focus more on the app, instead of worrying about acquiring and releasing memory.

However, if more than one thread tries to access a variable simultaneously then the reference counting mechanism might wrongly increment or decrement the reference count of a variable resulting in thread race conditions. Because of this, a variable might be left uncleaned causing leaked memory, or even worse if a variable is cleaned at the wrong time our application might crash.

This is where Python's GIL mechanism comes in, it is the job of GIL (Global Interpreter Lock) to make sure that at any given time, only a single thread has access to variables and data structures. This avoids all the nasty thread race conditions and false modification of the reference counting variables.

A point to be noted here is that GIL (Global interpreter Lock), is different from other locking mechanisms used by various programming languages for thread-safe data access. Unlike other locking mechanisms which lock individual variables and data structures, GIL is the lock around the Python's interpreter itself, meaning any python code which requires execution has to explicitly acquire the GIL lock. The effectively results in single-threaded execution of any CPU-bound application.

Living happily with GIL (Bypassing GIL)

There are multiple ways to bypass GIL, firstly the GIL mechanism only exists in the original CPython implementation, and does not exist in Jython and IronPython, if your application along with its dependent libraries is available in some other Python implementation, then you can use that interpreter without worrying about the GIL.

Secondly, we can also utilize Python's Multiprocessing module, which lunches multiple Python processes in the memory, each with its own interpreter. However, creating and launching processes is still heavier than launching multiple threads.

Nothing in life is to be feared, it is only to be understood. Now is the time to understand more, so that we may fear less. Marie Curie

Let's build a `CLI Based YouTube Launcher` in Python

Aamir — Sat, 15 Aug 2020 16:16:35 +0000

Hey Guys, I wanted to build and share a simple python based command-line utility that I put together for personnel use. This is a small fun little project which you can put together as well in an afternoon or morning in case you're an early bird. So grab a snack and let's dive right in.

The Problem (Hint, My Laziness)

I found myself constantly visiting some of my favorite YouTube channels, sometimes multiples times a day. And as you could imagine it involves quite a lot of typing (Says, my inner lazy programmer). So I automated this tedious process, below I've explained the approach I took to develop a CLI based solution for the above-described scenario.

Features identification.

I restricted my self to three commands to meet our primary goals with this utility, but once developed this can easily be extended to add other useful features.

I have developed and tested this utility to work on a Linux machine, but it can be very easily ported to a windows machine.

Basic Commands.

yt.py is our main command-line utility.

1) yt.py Linus tech tips
2) yt.py -g space
3) yt.py -l

  Side note, on a windows system, you would have to prefix yt.py
  with a python interpreter, somewhat like the following.

1) python yt.py Linus tech tips 
2) python yt.py -g space
3) python yt.py -l

The first command is the most basic use case, and maybe the most useful one, in which a user may type a channel name (it does not have to match exactly, just as close as possible) after our main yt command.
Next variant is slightly more interesting, where we are allowing a user to launch a group of channels with a single keyword after -g (group flag).
-l (list flag) will simply list the channels currently being tracked by our small utility as well as some meta-data tied to them.

Data Storage

I've decided to go with a JSON based storage structure, just because it's quite easy to incorporate in our codebase, and the majority of the developers are familiar with its syntax. If you'd like you can choose to use some other storage structure e.g YAML.

JSON file contains a list of channels, where each channel has, name, ,URL and group fields. You can have multiple groups defined with spaces in between them.

Sample JSON file that I will be using for this project.

{
   "channels" : [
      {
       "name" : "Linus tech tips",
       "url" : "https://www.youtube.com/c/LinusTechTips/videos",
       "groups" : "tech technology"
      },
      {
       "name" : "Marques Brownlee MKBHD",
       "url" : "https://www.youtube.com/c/mkbhd/videos",
       "groups": "tech technology"
      },
      {
       "name" : "Tim dodd The Everyday Astronaut",
       "url" : "https://www.youtube.com/c/EverydayAstronaut/videos",
       "groups" : "space rockets"
      },
      {
       "name" : "SpaceX",
       "url" : "https://www.youtube.com/c/SpaceX/videos",
       "groups" : "space rockets"
      }
   ]
}

For the sake of better understanding, I have broken up the code into small snippets. I have heavily commented out the code, to point out important details of implementation.

There are three main modules.

1) yt.py (Responsible for CLI parameters gathering, JSON data loading from file, and linking modules).

2) CLIArgsParser.py (Parses CLI arguments, and chooses appropriate action). More on this in the coming sections.

3) YoutubeLauncher.py (Executes the action chosen by CLIArgsParser.py).

Let's dive into each module one by one. I will be describing class methods individually and will add Github links at the end of each section.

1) yt.py

Dependencies for yt.py

#!/usr/bin/python
import sys   
import json  
import os

#Custom Imports
from CLIArgsParser import CLIArgsParser
from YoutubeLauncher import YoutubeLauncher

We begin with some basic level validations of command line parameters, making sure that the user is using the utility in the right manner, else we display some helpful text in regards to the usage of our app.

if ( __name__ == "__main__"):
    args = sys.argv

    # Make sure at least 2 parameters (filename + channel name) are provided
    args_good = True
    if (len(args) < 2):
        help_txt = " Please provide proper arguments, E.g\n\n  1) yt <channel name> \n    Example => yt linus tech tips\n\n  2) yt -g <group name>\n    Example yt -g technology\n\n  3) yt -l # To list channel names with meta data."
        print(help_txt)
        args_good = False

     # Tidy up the parameters for the rest of the code
    if(args_good):
        #Transform text to lowercase
        args = list(map(lambda x: x.lower(), args)) 
        #Skip filename
        args = args[1 : len(args)] 
        main(args)

main() is responsible for gluing together different parts of the application, it invokes different modules and interchange data between them.

def main(args):

    #Load channel data
    channels_data_json = loadChannelDataFromFile()["channels"]
    if channels_data_json == None:
        return


    # Parse Arguments with our custom CLI parameters parser
    # It's not the best implementation of a CLI parser out there
    # But it will do our job just fine.
    cliParser = CLIArgsParser()

    # In case of successful parsing, we will get an array containing
    # [action, data-required-to-perform-this-action] structure
    # This [action, data] can be to launch a single channel or a group of channels or to just simply list channels.
    # For more information, please keep reading, CLIArgsParser is described in much more detail below.
    command_data = cliParser.parseCLIArguments(args)

    #If a Critical Error Occured
    if (command_data[0] == "-e" ):
        #Print the error and stop execution
        print(command_data[1])
        return

    # Perform action, using YoutubeLauncher
    # YoutubeLauncher Requires following parameters
    #   1) Channels data
    #   2) command_data, which contains the [action,data] structure essentially letting it (YoutubeLauncher) know what to do
    youtube_launcher = YoutubeLauncher(channels_data_json , command_data)

    #Execute
    youtube_launcher.launch()

loadChannelDataFromFile() Loads the channels data from the JSON file.

def loadChannelDataFromFile():
    filename = os.path.join(os.path.dirname(__file__) , "channels.json")
    try:
        with open(filename, 'r') as channels_data_file:
            return json.load(channels_data_file)
    except IOError as error:
        print("{}".format(error.message))
        return None#Stop Execution

Github Link of yt.py

2) CLIArgsParser.py

This is our homegrown simple command-line arguments parser module (it's not perfect). Its primary job is to generate and return an array of action and data structure like [action, data] based upon provided parameters. This [action, data] structure is a requirement for our YoutubeLauncher.py which operates on it. This parsed structure lets the YoutubeLauncher.py module know about, what the user has asked for and what it is supposed to do. It (CLIArgsParser.py) also raises relevant parsing errors and lets the user know if the given parameters are not in compliance.

Following are some of the actions, and what they mean.

-e Indicates that some error has occurred while parsing. In this case the data will contain the error generated by the parser.
-c Indicates a channel launch command, data will be the name of the channel to launch.
-g Indicates a group launch of channels command, data will contain group keyword/name
-l Indicates a list flag, data will be empty for this one.

You can add more flags in this section according to your needs.

# Responsible For Parsing Command-Line parameters 
# And Generating [action, data] structure
class CLIArgsParser:


    #Returns an Array containing two items
    # 1) Command, this could be -c for single channel launch, -g for group launch or -l to only list channels, finally -e if there were any errors during parsing
    # 2) Data, this is the data required for the said command
    # 3) For Example, [-g , "technology"], will indicate to channels group with keyword `technology`
    def parseCLIArguments(self,args):

        CHANNEL_FLAG = "-c"
        GROUP_FLAG   = "-g"
        LIST_FLAG    = "-l"
        ERROR_FLAG   = "-e"

        #Handle single channel launch, Consider Everything is Query, join and return
        if(self.noFlagsProvided(args)): 
            return [CHANNEL_FLAG , ' '.join(args)]

        # Code does not handle both cases (-l and -g) at the same time, RAISE_ERROR
        elif (self.bothFlagsProvided(args)): 
            return [ERROR_FLAG, "ERROR: -g and -l flags can't be provided simultaneously\nPlease only provide one flag at a time."]

        #Handle group case, extract group query string 
        elif ("-g" in args): 
            group_query_index = args.index("-g") + 1

            # Check if group query exists after -g flag
            if(group_query_index < len(args)): 
                return [GROUP_FLAG , args[group_query_index]]
            else: #Raise Error
                return [ERROR_FLAG , "ERROR : -g flag provided without specifying group"]

        # Handle channel listing case        
        elif ("-l" in args):
            return [LIST_FLAG,None]


        else:
            return [ERROR_FLAG, "ERROR: Unknown error occurred while parsing arguments."]



    #Helper Methods
    def noFlagsProvided(self,args):
        return "-l" not in args and "-g" not in args

    def bothFlagsProvided(self, args):
        return "-l" in args and "-g" in args

Github Link of CLIArgsParser.py

Ok so at this point a lot of the work has been done. All that is left is the execution of our [action, data] by YoutubeLauncher.py module.

3) YoutubeLauncher.py

Dependencies

from fuzzywuzzy import fuzz # For String Matching operations
import webbrowser
from colored import bg, attr # FOr printing pretty console output

This module is in-charge of, actually executing the [action, data] structure which is generated by CLIArgsParser.py module, along with this it also receives the list of channels from the yt.py module.

fuzzywuzzy is a very good python module, for string matching operations, it has many methods depending on your requirements, whether you'd like to have full string matches or partial string matches. It returns a percentage depending on the amount of match.

webbrowser is another handy module, it allows us to quickly openURLS in a browser window, it can also work with different browsers.

Last but no the least, colored. Well, we are using this one just for the sake of some aesthetics, to print out some colored console output.

Let's break up YoutubeLauncher.py

class YoutubeLauncher:

    def __init__(self , channels_data_json, action_data, match_percentage = 65 ):

        # Store Channel data and [action, data] structure
        self.channels_data_json = channels_data_json
        self.action_data = action_data
        self.match_percentage = match_percentage

        #Expected action/command flags
        self.CHANNEL_FLAG = "-c"
        self.GROUP_FLAG   = "-g"
        self.LIST_FLAG    = "-l"

There is nothing much going on in the constructor, we are basically storing the list of channels and the [action, data] structure, defining some flags and that's pretty much it. However, there is this match_percentage parameter which I'd like to point out. By default, I have set it to 65, but you can change it if you want to. It essentially sets the bar for the matching percentage between two strings, if you set it too low then it will start matching channel names and groups even if they do not really match. So it is something you can play with.

 # Core Method, will call other supporting methods implicitly
    def launch(self):
        command  = self.action_data[0]
        data = self.action_data[1] 

        #IF Parser has specified a single channel launch action/command    
        if (command == self.CHANNEL_FLAG):

            matching_channel = self.__findBestMatchingChannel(data)
            if matching_channel != None:
                self.__initiateYoutubeLaunch(1, matching_channel)
            else:
                print("No Matching channel found.")

        #if parser has specified a group launch action/command
        elif (command == self.GROUP_FLAG):
            matching_channels = self.__findChannelsWithBestMatchingGroup(data)
            if (len(matching_channels) > 0):
                i = 1
                for matching_channel in matching_channels:
                    self.__initiateYoutubeLaunch(i, matching_channel)
                    i += 1
            else:
                print("No Matcing groups found.")

        #if parser has specified list action/command
        elif(command  == self.LIST_FLAG):
            self.__listAvailableChannelData()

launch(), reads the [action, data] structure, and calls supporting methods accordingly. It does this by matching the action flag parameter, which is at index 0, of [action, data] array with its own internally defined flags.

Supporting Methods



    def __findChannelsWithBestMatchingGroup(self, group_names):
        matching_channels = []
        for channel in self.channels_data_json:
            group_matching_score = fuzz.partial_token_set_ratio(group_names, channel["groups"])
            if(group_matching_score >= self.match_percentage):
                matching_channels.append(channel)

        return matching_channels

    def __findBestMatchingChannel(self, channel_name):

        best_match_channel = None
        channel_with_max_score = 0

        for channel_index in range(0 , len(self.channels_data_json)):

            current_channel = self.channels_data_json[channel_index]
            local_score = fuzz.partial_token_set_ratio(channel_name, current_channel["name"])

            if(local_score > channel_with_max_score and local_score > self.match_percentage):
                best_match_channel = current_channel
                channel_with_max_score = local_score

        return best_match_channel


    def __listAvailableChannelData(self):
        i = 1
        for channel in self.channels_data_json:
            data_to_print = "{}) {} {} {}\n      URL = {}\n      Groups = {}".format(i, bg(25) ,channel["name"], attr(0), channel["url"], channel["groups"])
            print(data_to_print)
            i += 1

These methods are called directly against -c, -g, or -l flags.

def __findBestMatchingChannel(self, channel_name):
will return a single matching channel along with all of its meta-data.

def __findChannelsWithBestMatchingGroup(self, group_names):
will return a list of channels with a matching group along with meta-data.

def __listAvailableChannelData(self):

Will only print names and meta-data about channels on the console.

 def __initiateYoutubeLaunch(self,counter, channel):
        print("{}) {} Launching {} {}\n".format(counter, bg(25), channel["name"], attr(0)))
        webbrowser.open_new_tab(channel["url"])

And Finally, def __initiateYoutubeLaunch(self,counter, channel):
will call the webbrowser module to open URL in a new tab.

Final thoughts

I had a lot of fun working on this side project and I hope that you will too. Projects like these are not only a good way to polish up your coding skills, but also an integral part of your journey as a developer. To take some problem in your daily life and automating it with code. After all, this is what programming is for, to automate stuff and making your life and the life of others around you just a little bit more easier.

Chao, Aamir out.

To see the world, things dangerous to come to, to see behind walls, draw closer, to find each other, and to feel. That is the purpose of life.

What is Hoisting In JavaScript

Aamir — Fri, 24 Jan 2020 19:23:59 +0000

Sooner or later you will encounter the concept of "Hoisting in JavaScript", It does sound like quite a complicated thing, but hopefully, by the end of this quick article, we will be able to demystify it. You will know exactly why you can invoke functions even before they are declared, which by the way as many of you know is considered a crime in many other languages and the code would not even compile.

Lets quickly see an example of JavaScript Hoisting.


//Calling function and variables before they are defined

foo();  //Will output "Hello World, from foo"
console.log(bar); //Will Output undefined


function foo(){
   console.log("Hello World, from foo");
}

var bar = "Hello World, from bar";


//We will later see, why our variable `bar` is printed undefined

Hoisting What it is not

If you do a quick google search about "Hoisting in JavaScript", you will be presented with many answers, which talk about that the JavaScript engine physically move your variables and functions at the top of the code file, and now that they are defined at the top of your code, they can be used and invoked without a problem. This is not correct

"Honestly the word Hoisting is not very intuitive for understanding how JavaScript Hoisting work's under the hood".
When I first learned about it. My mind was instantly drawn to the incorrect explanations because the word Hoisting does give you this impression that the variables and functions are somehow hoisted above the rest of your code.

Hoisting in JavaScript

To fully understand how Hoisting works, we need to delve a little deeper and learn how the JavaScript Engine executes your code. There are essentially two phases of code execution.

1) Execution Context Creation Phase.
2) Code Execution Phase.

Execution Context Creation Phase

Before executing your code line by line. JavaScript engine will setup the environment for your code execution, It scan's your code file and then reserve's the memory space required for those variables and functions. For variables, it's a little different, while setting up space for variables the JavaScript engine will also initialize them with undefined type. You might be able to tell now, why we were not able to print the value of bar in the above code and instead we got undefined but were able to successfully invoke foo() function. This is because the Execution Context Creation Phase only reserves memory for variables and initializes them with undefined type, the final value is not set until the actual Code Execution Phase begin's.

Code Execution Phase

Once the Execution Context is created JavaScript engine will start executing your code line by line in the order in which you have written your code. Because of the previous phase and the so-called Hoisting you will have access to functions and will be able to call them wherever you would like. But as you saw the space for variables is only reserved and by default set to undefined.

Hopefully, by now you will have a better understanding of how JavaScript Hoisting works under the hood.

Templated Functions In C++ For Beginners

Aamir — Wed, 25 Dec 2019 16:26:52 +0000

Hey there, In this brief article, I'll explain the concept and usage of the templated functions in c++. I'll first introduce you to the problem and then how templated functions provide an elegant solution to it. This is not going to be a long-winded article, but if you're a coffee or tea lover, then grab a cup my friend and let's dive right into it. ☕

Introduction to Templates in C++

Template functions and class templates are one of the many superpowers of C++. By using template-based functions and classes you can generalize your code to handle more data types with less code. It also saves you the hassle of refactoring multiple similar functions by allowing you to just refactor the single templated function or class. For this article, we are going to focus on templated functions only.

The Problem

Consider the following example. We are trying to implement a basic add() function. To handle different cases for different data-types, we have to overload fundamentally the same function for different data-types, as we need them.

#include <iostream>

int add(int a, int b) {
    return a + b;
}

float add(float a, float b) {
    return a + b;
}

long add(long a, long b) {
    return a + b;
}



int main() {

    int result_x = add(10, 20);
    int result_y = add(9.7f, 20.3f);

    std::cin.get();
    return 0;
}

Not only it is a lot of redundant code, but it would also be an absolute nightmare to refactor this kind of code in a large codebase.

Templates to the rescue....

How Templated Functions Resolve This Issue

Templates allow you to write a single function, which will be responsible for handling different data-types. What happens behind the scenes is that when you write a templated function, and then later call it with some data-types in your code. The compiler will see it and will generate function definitions tailored to it own its own, at compile time.

So essentially you have automated what you were doing before manually, and letting the compiler handle it implicitly at compile time.

No Redundant Code ✔
Easy To Refactor ✔

Defining A Templated Function

We start by prefixing the function definition with a template<class T> directive, which essentially informs the c++ compiler, that the following function is template-based, please look out for its function calls in the code and generate function definitions accordingly at compile time.
class T is similar to a data-type and variable name, only this time it's of a general data-type that will be inferred at compile time.

Here Is, How Our Modified Templated Add Function Looks Like

#include <iostream>
 template<class T>
T add(T a, T b) {
    return a + b;
}

int main() {

    int result_x = add(10, 20);
    int result_y = add(9.7f, 20.3f);

    std::cin.get();
    return 0;
}

We are down from three overloaded functions to only one. A clean and simple solution.

Remember, we have to keep this in the back of our minds, that for it to work the definitions for int based and a float based add() function has to be present at runtime, even though we have not explicitly placed the definitions for an int and float based function in our code. At compile time, the compiler will notice that we have called a templated function with an int and float parameters. It will then generate these specific definitions for us while replacing T with the actual data type, which in this case will be int and float respectively.

It's also pertinent to mention here, currently, in our add function, we are only working with a single Templated parameter, what that means is, in add(T a, T b) both a and b are of a single data-type,
it could be of int or float or something else, but not a combination.

Of course, you can have more than one templated parameter, we just have to update our template definition. So let's say you want to have two different types of parameters. The function definition for this scenario would look something like the following.

#include <iostream>

//consider class T as data-type 1, and class P as data-type 2
template<class T, class P> 

//Please note, We could have returned a different datatype, it's up to the programmer
//In the following case we have returned a generic data-type, but we can also return other data types such as int, float, etc
//Its the choice of the programmer to decide what they want to return.
P add(T a, P b) {
    return a + b;
}

int main() {

    float result_x  = add(10, 20.5);
    float result_y  = add(9.7f, 20.3f);

    std::cin.get();
    return 0;
}

If you are still not really convinced by the beauty and power of templates, then I highly encourage you to have a look at any of the c++ collections. Like std::vector, you could have a vector of ints or a vector of floats, all thanks to templates.

Final Words

The concept of generics or what c++ calls templates is very popular in many programming languages. Being a developer you will have to work with generics/templates almost every day. So it's a good idea to learn about it early on with hands-on practice.

Aamir, Out

Do not go gentle into that good night,
Old age should burn and rave at close of day;
Rage, rage against the dying of the light.
Dylan Thomas.

A brief introduction to Java Lambda expressions

Aamir — Thu, 06 Jun 2019 08:55:40 +0000

Let me introduce you to a programming scenario that you are most probably already familiar with if you have been programming in Java for some time now.
Often you need to override a functional interface to provide callbacks for event listeners or to provide a custom implementation of a function, let's have a look at the following example as a refresher, where we are passing a callback method to the Greeter class which is calling our provided callback method after a 5 seconds delay an example of functional interface

interface onGreetCallback{
   public void greet(String greetMsg);
 }

class Greeter{
   private onGreetCallback callback;
   Greeter(onGreetCallback callback){
    this.callback = callback;

    //call the provided callback after 5 seconds delay
    try{
     Thread.sleep(5000);
     this.callback.greet("Hello, Pardon me, I am 5 seconds late to greet you.");
    }catch(InterruptedException  e){
      e.printStackTrace();
    }

   }
 }

 class DEMO{
   public static void main(String args[]){
    Greeter greeter =  new Greeter(new onGreetCallback(){
       @Override
       public void greet(String greetMsg){
         System.out.println(greetMsg);
       }
    });
   }
 }

The above code is very common, and you will come across similar code on daily basis in java. As you can see, it takes some time to write the override method which is being passed into Greeter class constructor.
From Java 8, Lambda expressions have been added to simplify this part of code and make it look cleaner and elegant, not to mention shorter.
Let's write the main function again, this time with Lambda Expressions.

 public static void main(String args[]){
    Greeter greeter =  new Greeter(msg -> System.out.println(msg));
 }

Lambda expressions just saved us at least 4 lines of code. In the following article, I am going to talk about lambda expressions in detail the syntax, where to use, and some comparisons with the older approach. So without further ado, let's get into the nitty-gritty details of Java Lambda Expressions.

In above modified code, msg -> System.out.println(msg) is the lambda expressions code where msg is the input parameter and
System.out.println(msg) is the body of the lambda expression, -> is what separates input parameters from the body of the lambda.

Above lambda expression has been written in a very condensed manner, a more expanded version would look like this.

  Greeter greeter =  new Greeter((msg) -> {
          System.out.println(msg);
  });

If you have only one input parameter you can skip the brackets, but if you have more than one input parameter then you have to use brackets e.g.
Let's also pass in a name parameter into our example.

  Greeter greeter =  new Greeter((msg, name) -> {
     System.out.println("Hello " + name);      
     System.out.println(msg);
  });

The curly brackets are also only needed if you have more than one line of code, that is why the first lambda expression I showed you is very compact.

 public static void main(String args[]){
    Greeter greeter =  new Greeter(msg -> System.out.println(msg));
 }

The return keyword is also not required if there is only a single statement.
Let's see an example where we have more than one statement inside the lambda body and then see how we can write the same lambda expression with just a single line to remove the explicit return keyword.

 interface FilterInterface{
    boolean filter(int number);
}

//Class to call the user implementation of method, on given data
class Utils {
    private FilterInterface filterInterface;

    //User provided Transformation Method
    void setFilterMethod(FilterInterface filterMethod) {
     this.filterInterface = filterMethod;
    }
    //Transform method to apply user-provided Method on given data
    List transform(List data) {
        List filtered_data = new ArrayList<>();
        for (int i = 0; i < data.size(); i++) {
            //Test with user provided Filter method
            if (this.filterInterface.filter(data.get(i))) {
               filtered_data.add(data.get(i));
            }
        }
        return filtered_data;
    }
}
public class Main{
    public static void main(String[] args) {
        List data =  new ArrayList<>();
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);

        Utils utils =  new Utils(); //Instantiate object of our custom util class
        //Let's provide a Lambda Expression to filter Even numbers
        /*
        * Because we have more than a single line of code, we have to use the return keyword
        * */
        utils.setFilterMethod(x -> {
            if (x % 2 ==0){
                return true;
            }
            return false;
        });

        //Apply the provided transformation function
        List filtered_data =  utils.transform(data);
    }
}

I have deliberately written the above lambda expression in this long manner, let's write it with a single line and skip the return keyword.

        utils.setFilterMethod(x -> x % 2 == 0);

Lambda Expression to Functional Interface mapping

To map the lambda to a functional interface, some conditions must be met.

The interface must at least contain one abstract method.
Lambda expression input parameters must match the input parameters of the abstract method.
The return type of the lambda expression must be matched with the return type of the abstract method.

Lambda expressions also allow you to capture variables.

You can capture variables declared outside the body of the lambda function. The following variables can be captured inside the body of the lambda.

Local variables.
Instance variables.
Static variables.

Local variable capture

  class DEMO{
    final String name = "Aamir";
    public static void main(String args[]){
     Greeter greeter =  new Greeter((msg) -> {
       System.out.println("Hello " + name);      
       System.out.println(msg);
     });
   }
  }

In the above example, we are capturing the name variable inside the lambda body. Local variable being captured must be declared as final, if the variable is not declared as final then the java compiler will complain.

Instance variable capture

Lambda expression also allows you to capture the Instance variables, an important difference worth noting here is that this is not possible in the classical approach where you implement an interface anonymously, this is because an anonymous interface has its own body where a lambda expression does not.

 class MyClass{
   private String name = "Aamir";
   Greeter greeter =  new Greeter((msg) -> {
     System.out.println("Hello " + this.name);      
     System.out.println(msg);
   });
 }

Static Variables capture

 class DEMO{
    private static String name = "Aamir";
    public static void main(String args[]){
     Greeter greeter =  new Greeter((msg) -> {
       System.out.println("Hello " + name);      
       System.out.println(msg);
     });
   }
}

Now that we have seen how the lambda expressions work under the hood, their structure, and different flavors of syntax, let's see a more practical example from Java Stream API, which allows you to write your code in a declarative fashion.

Applying a transformation/map function across an array or a list

public class Main{
    public static void main(String[] args) {
        int fav_nums[] = {1,2,3,4,5};
        //Apply the array transformation Using a Lambda Expression
        int new_fav_nums[] = Arrays.stream(fav_nums).map(x -> x *2).toArray(); // 2,4,6,8,10
    }
}

Filter names based on starting character

public class Main{
    public static void main(String[] args) {
        String names[] = {"Aamir" ,
                            "Ali" ,
                            "Atif" ,
                            "Siraj" ,
                            "Shehriyaar" ,
                            "Shehroz" ,
                            "Hassan" ,
                            "Jibran"};
        //Applying filter to only get names starting with "A"
        String filtered_names[] = Arrays.stream(names).filter(name -> name.startsWith("A")).toArray(String[]::new);
        //Aamir
       // Ali
      //  Atif
    }
}

Actually we can make the above code even more compact, by abstracting the logic inside the lambda expression and taking it out in its own method, by passing in a Method Reference.

 class MyFilters {
    public static boolean filterName(String name){
        return name.startsWith("A");
    }
}
public class Main{
    public static void main(String[] args) {
        String names[] = {"Aamir" ,
                            "Ali" ,
                            "Atif" ,
                            "Siraj" ,
                            "Shehriyaar" ,
                            "Shehroz" ,
                            "Hassan" ,
                            "Jibran"};
        //Applying filter to only get names starting with "A"
        //Using a method reference
        String filtered_names[] = Arrays.stream(names).filter(MyFilters::filterName).toArray(String[]::new);
        //Aamir
       // Ali
      //  Atif
    }
}

The filter will call our supplied Method reference on each item inside the array.

For those of you who are asking what can be the use of abstracting out the lambda expression logic into its own separate class, allow me to share some use cases, this process will be very useful if you need to apply some similar kind of filter, map, reduce operations on different sets of arrays or lists. Or maybe your lambda expression body is getting too messy.
It also makes your code more readable to other developers, who will instantly get the meaning of your code by the name of the Method Reference you passed in, will be easier for them to understand your thought process. It will also stop you from going absolutely crazy if 6 months later you decide to make some changes. I know we all have been there.

:: signals the java compiler that this is a Method Reference

You can reference the following types of methods:

Static method.
Instance method on parameter objects.
Instance method.
Constructor.

Hopefully, by now you have a good understanding of what Java Lambda Expressions are, how to write them, their usage. If this is your first encounter with lambda's you may need some more time and practice to fully grasp it, but trust me once you have learned and mastered them, they will be your first choice of the tool while dealing with collections of data.

“Always focus on how far you've come, not how far you have to go.”

Introduction to c++ function Pointers

Aamir — Wed, 29 May 2019 06:07:08 +0000

Function Pointers in “C++” can be a little daunting at first for many people mostly because of their alien-looking syntax, but when you look at them more closely you will find out that it's very simple, straightforward and important concept of c++.

Function Pointers essentially allows you to pass and store functions to variables or in other functions for later use by some other part of the code, at some later point in time. More formally a function pointer is a special type of variable that can point to any function having the same function signature. This is a very powerful tool and we will explore it briefly later in this article. But first, let’s jump straight into the code and get our hands dirty.

Let’s understand the syntax of the function pointer

int (* function_pointer)(int a , int b);
think of it like a normal c++ function where the first int is the return type of the function signature it can point to, (* function_pointer) is how we tell the c++ compiler that its a function pointer, you can name it whatever you’d like but (*) is important. Then the next part (int a, int b) are the arguments of the function signature which it can point to. That’s it you have now created your very first function pointer in c++.

With the syntax out of the way, let’s see why this is so powerful, in the above example we are passing an adder function to the function pointer variable, but this can be any function. You can write a multiply function, a division function, or a function that maybe adds the arguments first and then applies some kind of percentage on it, at the end of the day the function pointer will just call it.

But you might be asking, function pointers are cool but what are some real-world use cases

Let’s take the following example, suppose you are developing this c++ library for a company, which manages their employee's data and calculates bonuses for each employee based on certain conditions. The company also specifies that they have multiple departments and for each department, they would like different criteria for calculating bonuses. After taking these requirements you do some planning start coding. Your library has this core function that performs the following tasks.

1) Takes in data.
2) Parses it.
3) Cleans it.
4) Calculates bonus for each employee depending on the Department.

You Quickly notice that the core function is mostly similar in nature except the Last part, where you calculate the bonus. The problem is that the bonus calculation for different departments varies from each other. You can incorporate different scenarios as well but it will be very messy and not maintainable code. Also, what will you do if the company suggests altering the calculation of certain departments, maybe they don’t want to give a bonus to certain employees depending on their performance record, yes it will quickly become your favorite nightmare of all time, because the reality is, that this part of the function is subject to change quite often.

Enter Function Pointers to the rescue

With function pointers you can simply pass in a small function that will contain the exact implementation of the Bonus calculations for a particular Department, you don’t have to write multiple branch statements to detect the type of department, etc, instead you will have neat and elegant bonus calculation tailored for each department.

Let's see a code example for the above scenario
Our library class with the core function will look something like this

As we can see after performing all the similar operations the, core_functions calls a user-provided function pointer to get the bonus for each employee. Let's see how the above class can be consumed

The main function is passing a custom function to the Demo_lib core_function, which will be used for bonus calculation, you can write multiple functions specific to your needs and conditions, and the Demo_lib will simply call it when it will reach the bonus calculation part of the core_function

So with the use of function pointers we now have the ability to tailor different bonus criteria for different employees for a number of departments

What we have seen today is the classic function pointers in c++.
c++11 has introduced modern function pointers which makes defining them little simpler but more importantly also allows you to pass Anonymous lambda functions into other function pointers instead of writing standalone functions, Lambda functions can be really helpful to pass in as they can be declared on the fly since you don’t need them anywhere else. I highly encourage you to look up them, as they are the modern successors of c++ function pointers. And the perfect stepping stone in your c++ journey.

Chao, Aamir Out

In the middle of difficulty lies opportunity.
Albert Einstein