DEV Community: Tahir Raza

Kotlin from Php Eyes | First Look

Tahir Raza — Wed, 10 May 2023 07:33:10 +0000

As you might have heard about Kotlin, the new famous easily adoptable language for Java engineers. Kotlin was designed to be an alternative to Java with a concise and easy syntax without much of the boilerplate code as one would do in Java. So naturally it is easier for a Java engineers to learn Kotlin as they are already familiar with the ecosystem and all fancy names and building mechanism.

But for someone like me who has never worked with Java, but do have experience with PHP and Python, how this new language feels and look like?

Gradle/Maven buil
Namespaces vs packages
Delegates
Extension Functions
https://kotlinlang.org/docs/extensions.html#extension-functions
Lambdas
Scope Functions
https://kotlinlang.org/docs/scope-functions.html#function-selection
Data Classes
Equals and HashCode Functoions
Serialization
A million ways to do something

PHP: FPM | FastCGI | mod_php

Tahir Raza — Thu, 10 Nov 2022 07:19:59 +0000

PHP, a widely spread scripting language mainly used for websites or more specifically backend web development. You might have heard these terms mentioned in the title of the post but if you are someone like me, then you probably don't fully understand these things.

So todays post will be more about the definitions, conceptual differences and pros/cons for one over the other.

Whenever I want to learn something new I follow some simple steps:

Understand the meaning/definition of the new term
Learn about the history
Learn with examples and/or learn with alternatives

So let's try to follow this approach.

PHP

Meaning/Definition

PHP, originally extracted from Personal Home Page Tools, now stands for PHP: Hypertext Preprocessor.

History

Rasmus Lerdorf is the guy who created of PHP and Andi Gutmans and Zeev Suraski are the creators of the Zend Engine.
You can read an in detail historical background on the wiki page if you like but the interesting fact is PHP's first version was released way back in June 1995. Yes it's that old.

Example Usage

PHP executes on the server, while on the hand JavaScript executes on the client.
PHP is mostly used for backend web development but it is also fully capable to make command line applications.

Now as you know that PHP runs on the server, you may ask what servers? how does a server know how to run PHP? And that's where the mod_php, fastCGI and FPM comes into picture.

First things first, let's understand a few terms.

mod_php: Module PHP
CGI: Common Gateway Interface
FastCGI: Fast Common Gateway Interface FastCGI is a binary protocol for interfacing interactive programs with a web server. It is a variation on the earlier Common Gateway Interface (CGI).
FPM: FastCGI Process Manager

Ok so now you at least know the definitions of acronyms.

Today we will look into two different ways to run PHP on a server and there are two very well known backend servers used to run PHP Apache and Nginx.

So to run PHP on these servers there are two ways:
You can run PHP as a module in Apache server (mod_php) or you can run PHP as an independent process (PHP FPM) and configure the server to use the process to handle PHP files.

A simple google search ("php fpm vs mod_php") will give you a lot of good resources on how to configure these two and what are the benefits of one over the other but there are key differences I would like quickly share with you:

PHP FPM is way faster then mod_php
mod_PHP locks out processes and disrupts the performance of a website
HTTP 2 Support
If you want HTTP 2 support you should go with PHP FPM as mod_php does not support it.

A more detailed and in my opinion more accurate reading on this is a stackoverflow answer, please read here if you are interested.

Trees | A beautiful data structure

Tahir Raza — Fri, 15 Jul 2022 22:18:54 +0000

During my journey from the forest of data structures I saw a tree and I loved it :D Pardon me for the casual joke.
But yes, today I would like to talk a bit about Tree data structure.

If you have ever used a social media platform - you have been exposed to a system which heavily used trees data structure. Some people classify it as a hard one to understand but I think it is fascinating and makes our lives easier in a lot of cases.

The tutorial timeline will look something like this:

What is Tree?
Why it exist?
Types of Tree?
Real world examples
Implementation

Tree - What is it?

It is a non-linear hierarchal data structure that consists of nodes and edges. So it is a lot of new words so first let's get out the new terms out of the way.

Non-linear hierarchal: Unlike arrays or linked list this data structure is designed to hold data which is linked in a hierarchal manner. Hierarchal means it is capable of holding data which has a parent child relation within.
Node: A node is an entity that contains a key or value and pointers to its child nodes.
Edge: The link between any two nodes is called an edge.

NOTE: Tree is a data structure, and binary tree is a type of this data structure. Every binary tree is a tree but every tree is not a binary tree.

Tree - Why?

In simple words, we needed something to access data in an efficient way. Tree access time is better than linked list.

Another reason: Trees are really useful when you want to save data which naturally forms a hierarchal relation. Simplest common world example can be a family tree and rather trivial tech example can be one database indexing.

Real world examples

Database indexing is used using a special kind of tree called B-Tree or B+ Tree.
DNS - It also uses a tree data structure.
In some machine learning algorithm decision tree based learning is used.
XML parsers use trees.
Binary search tree, Heaps, Heap Sort, Huffman coding tree, syntax tree are also some of the examples where trees are used.

Implementation

Enough verbose, let get straight into the implementation.
As we know, tree is a collection to nodes related to each other with the edges so what does a tree node look like?

class Node():
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

Let's say if we want to create a tree like below. How can we do that?

#     1
#    / \
#   2   3
#  / \
# 4   5

One way would be to do it manually creating root/parent nodes and adding children to it but I would like to share a better way. We can write a function which recursively creates a tree from array.

nodes = [1,2,3,4,5]

The above array is the representation of the tree we are talking about and if you notice, if i is the parent node the left child is 2i+1 and the right child is 2i+2. Using this we can easily write the function to create the tree.

nodes = [1,2,3,4,5]

def createTree(nodes, i):
    if i >= len(nodes):
        return None

    root = Node(nodes[i])
    root.left = createTree(nodes, 2 * i + 1)
    root.right = createTree(nodes, 2 * i + 2)
    return root

Hmm, now we have created our tree but how can we see it? or more formally speaking, how can we visit all the nodes of our tree?
This is called traversing. If English is not your first language, like me, traversing means "travel across or through." or simply "move back and forth or sideways".
So how can we do that?
Traversing is mainly three types and it depends on the root node.

Pre-order
Post-order
In-order

Photo by Rodrigo Santos

Heapify a list into Max Heap

Tahir Raza — Fri, 15 Jul 2022 22:16:00 +0000

If you don't know - Heap is one of the awesome data structures you should learn. Why?

Heap can find min/max in O(1)
Insertion/Deletion can be done in O(logn) whereas in arrays insertion take O(n)
If you learn this data structure, you will be able to grasp heap-sort, priority queue and heapifying an array concept.

If you are interested to learn more about Heaps, here are some resources to get you started:

So how you can convert an array to a Heap.

list = [20, 5, 30, 10, 15, 45]

def getChildren(pIndex, list):
    leftIndex = pIndex * 2 + 1
    rightIndex = pIndex * 2 + 2

    left = -1
    if leftIndex < len(list):
        left = list[leftIndex]

    right = -1
    if rightIndex < len(list):
        right = list[rightIndex]

    return left, right

def heapify(list):

    for i in range(len(list)-1, -1, -1):
        p = list[i]
        left, right = getChildren(i, list)

        bigChild = max(left, right)

        bigChildIndex = 2 * i + 1
        if right == max(left, right):
            bigChildIndex = 2 * i + 2

        j = i
        while p < bigChild and bigChildIndex < len(list) and j < len(list):
            list[j] = bigChild
            list[bigChildIndex] = p

            j = bigChildIndex
            left, right = getChildren(j, list)
            bigChild = max(left, right)
            bigChildIndex = 2 * j + 1

    return list

print(heapify(list))

Photo by Pixabay

LinkedList | Python | Basics to Advance

Tahir Raza — Mon, 27 Jun 2022 11:33:23 +0000

Why we should learn this?

We all know data structures and algorithms are the foundation of being a good software engineer.

Usually these foundation concepts are considered to be worthy only if you are in university or you are preparing for an interview for a big tech company.

But I have a different take on this. As an engineer you should be asking yourself this question: "As an engineer should I know X?" and if the answer is yes then please put some time in that topic to be a good engineer in general not because you are trying to score a job.

So, the questions is, as engineers - you think we should know the most basic but useful data structure called Linked-List?

I heard a big yes!!

So let's begin:

Definition and Dictionary

Linked list is a linear data structure.
Basically it contains only two things: data and next
This data can be anything, from just an int to an array or dictionary.
next is a pointer which points towards the next Node
Node is just a name we use for every linked entity in the linked list. Node is somewhat similar to what you have in array as an index.

So in simple words, linked list is collection of Nodes linked together with pointers.

Why this data structure even exists?

One may ask, we already have a linear data structure known as arrays then why we created a similar but new one? Why?

Then let me ask a question:
How do you add a new element in the middle of an array?

Find where you want to add new element.
Add new element
And shift the rest of the array one

Linked lists solve such issues like shifting the array after adding a new element in the middle.

Implementation

In python, it is really easy create some classes to reflect this data structure, like the code given below:

class LinkedList:
    def __init__(self, head=None):
        self.head = None

class Node:
    def __init__(self, data, next=None):
        self.data = data
        self.next = next

Creating from Array

You might be wondering how can you create this linked list and see it in action.
For this we can write a simple function to create a linked list from array and then visit every node of the linked list with another function.

def createFromArray(nodeList):

    ll = LinkedList()

    prev = None
    for n in nums:
        curr = Node(n)

        if not prev:
            ll.head = curr
        else:
            prev.next = curr

        prev = curr

    return ll

# Make linked-list from array - O(n)
nums = [1,2,3,4,5]
ll = createFromArray(nums)

Traversing

For traversing or in simple words - visiting all nodes in a linked list we can do something like this:

def traverseList(ll):
    curr = ll.head

    while curr:
        print(curr.data, end=" -> ")
        curr = curr.next

# traverse a linked-list O(n)
traverseList(ll)

If you like this and want to learn more, just stick along and next we will talk about some common operations on linked list.

Happy coding.

Credits:

Cover Photo by Joey Kyber

Change the Approach | Different Ways to Solve Same Problem

Tahir Raza — Fri, 24 Jun 2022 11:53:11 +0000

The way we approach a problem decides the effort its going to take to solve it. It may seem like an obvious thing but sometimes we engineers get stuck thinking in just one direction and we cannot look the other way.

I would try to explain this with an example today.

Let's take this simple leet code example, Contains Duplicate

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

First Approach

Probably, the first solution in your mind is to loop over the entries in a way so that you can compare every element with the next one to check if its same and then just return true there. Sounds reasonable and also doable, let's look at the code here:

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:

        for i in range(len(nums)-1):
            for j in range(i+1, len(nums)):
                if nums[i] == nums[j]:
                    return True

        return False

The solution actually works and is not a problem for smaller arrays to do this but as you might have guessed this is a brute force solution and the time complexity for this solution is O(n^2) BigO of N-Square, because we will execute both loops n-1 times.

Second Approach

The second approach is completely different than the first one and it improves the algorithm greatly.
In this approach, instead of comparing every element with the rest of the elements, we will keep track of all the visited elements and whenever we encounter an element which we have visited/tracked already we know we have a duplicate entry in the array.
Some simple python code will solve it really easily.

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        visitedHashMap = {}

        for num in nums:
            if num in visitedHashMap.keys():
                return True

            visitedHashMap[num] = num

        return False

This approach is far more efficient than the first one but it uses more memory which is O(n) as we will created a hash map for storing the visited elements.

Second Approach - Slight variation

Instead of checking if the num key exists in the hashMap we can simply try to get the key and we know if we don't have a key, python will throw a KeyError and we can pass this exception as we know there are keys which are checked for the first time.

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        visitedHashMap = {}

        for num in nums:
            try:
                visitedHashMap[num]
                return True
            except KeyError:
                visitedHashMap[num] = num

        return False

Which approach is better, I leave that judgement to you guys but I explained the above scenarios in order to build some background for the actual problem I wanted to share with you guys.

The Actual Problem

There's a relatively famous problem where you are being asked to provide the count of all possible combinations from an array of integers which adds up to a given target.
The problem statement is:

Given an array nums of positive integers, provide count for all the possible combinations which adds up to a given target. The combinations should have at least two elements and should be in descending order.

Input: nums = [1,2,3,4], target=5
Output: 2

Explanation

For the given target 5, the possible combinations satisfying the above said conditions are:

[4,1]
[3,2]

If you are someone like me, you will also try to create all possible combinations which satisfy the above conditions for the given target and then just return the count of those combinations.

While this is also a valid approach and it can work, there's a slight problem.

Imagine if the target is 300 and the given nums array is [1,2,3,4,5,6,7,8,9,........199]
Can you imagine how many valid combinations you can have in this case? Let's just say A LOT!!!

I wrote a solution in python with some dynamic programming techniques but still I was unable to calculate the combinations for even bigger numbers.

After a bit of struggle I took a break - sat in my garden and reflected on my approach and realise I have to change my approach because if my current approach can only provide solution to some extent only, that can not be a valid solution.

Finally, long story short, after reading a bunch of mathematics forum I found out this problem is related to a domain of mathematics called partition and once I understood that it was really easy to write some python code which solve the problem in really minimum time.

Python | A simple Stack Class

Tahir Raza — Sun, 12 Jun 2022 16:42:54 +0000

Today I want to talk about a famous, basic but pretty wonderful data structure we all read in our universities or colleges.

Stack

A stack is a linear data structure that follows the principle of Last In First Out (LIFO). This means the last element inserted inside the stack is removed first.

You can think of the stack data structure as the pile of plates on top of another.

Here, you can:

Put a new plate on top
Remove the top plate
And, if you want the plate at the bottom, you must first remove all the plates on top. This is exactly how the stack data structure works.

Applications

To reverse a word - Put all the letters in a stack and pop them out. Because of the LIFO order of stack, you will get the letters in reverse order.
In compilers - Compilers use the stack to calculate the value of expressions like 2 + 4 / 5 * (7 - 9).
In browsers - The back button in a browser saves all the URLs you have visited previously in a stack.

Key functions of a Stack

Push: Add new element
Pop: Remove an element from last
Peek: Get the last element without removing it

Cherry on Top

In the following implementation instead of using built-in functions to check empty or length of stack we will use an extra variable count to keep track of these things.

Code

from typing import Type

class Stack:

    elements = []

    count = -1

    def push(self, data):
        self.elements.append(data)
        self.count += 1

    def pop(self) -> int:
        if self.isEmpty() is True:
            raise Exception('Nothing to pop!')

        self.count -= 1
        self.elements.pop()

    def peek(self):
        if self.isEmpty() is True:
            raise Exception('Cannot peek an empty stack')

        return self.elements[self.count]

    def isEmpty(self):
        return self.count < 0

Python | OOP | Classes

Tahir Raza — Sun, 12 Jun 2022 15:55:29 +0000

Recently, I have realised that it is really hard for the beginners to follow the official documentations and most importantly, make sense out of it.

Since Python is one of the easy to use language and a lot of people want to get started with it, I think it is a good idea to share the knowledge in plain English.

For this reason, I am starting this blog post series to explain Python's object oriented model.

Python's object oriented model has the following basic characteristics:

It is a mixture of the class mechanisms found in C++ and Modula-3.
Classes themselves are objects. This helps for importing and renaming.
Class members are public (Methods and Data Members both).

class Example:
    classAttribute = 12345

example = Example()

print(example.i)

Every class method needs to have self as the first argument, which is provided implicitly by the call.

class Example:
    classAttribute = 12345

example = Example()

print(example.i)

Aliasing: Objects have singularity, and multiple names can be bound to the same object. This is known as aliasing in other languages. Simply speaking, if you pass on object to a function as a argument and change the object inside that function, it will be changed in the main function as well.

from typing import Type

class Counter:
    count = 0

def changeCount(counter: Type[Counter]):
    counter.count = 5

counter = Counter()

print(counter.count)
# 0

changeCount(counter)

print(counter.count)
# 5

Most namespaces are currently implemented as Python dictionaries.

What, Why! Always know the "What" and "Why".

Tahir Raza — Mon, 30 May 2022 14:14:02 +0000

Sometimes we as programmers tend to just do stuff for the sake of completing a task which is fine in most cases but sometimes we do something without enough knowledge and break our production servers. Yes, sad but true, we do that sometimes.

In today's quick blog post I just want to emphasise on one thing: Always, always know what are you doing and why are you doing that.

I will try to paint the picture with some real life examples.

In our day to day work we sometime encounter ourselves where we have to use a software and tweak it's configurations according to our needs. These configs are generally a common place where we seem to just bypass and do what we find first.

The most common example I can think of right now is configuring a web server according to your needs. Usually we tend to just goolge for our needs and copy-paste the first stackoverflow result.

For example tweak a lot of configs for an nginx FastCGI to name a few buffers, it's size param etc etc. But before you touch that piece of code make sure you know what FastCGI is, what buffers are and what does it really mean to change these configs.

Another example, supervisor configs.

If you have ever used supervisor (if not read here) you'll know we have to configure it how it should consumer or run a command. And we can provide options like:

--limit = X
--memory-limit = Y
--time-limit = Z

All these configurations actually have a very meaningful impact on how supervisor should treat a command.

So before you try to tweak anything in your configurations make sure you give it a few minutes to read about it and you should know why you are doing it.

Palindrome Number | Different techniques for detection

Tahir Raza — Sat, 16 Apr 2022 10:08:56 +0000

Palindrome is a number which is same if you read if from left to right or from right to left.

For example, 121 does not matter from which side you start reading it, it will remain same - 121.

The problem statement looks like this:
An integer is a palindrome when it reads the same backward as forward.
Given an integer x, return true if x is palindrome integer.

Whenever you encounter a problem don't jump right into the solution, instead try to think it through, try to think about the different edge cases of the problem. For example in this one, you can ask the interviewer the following questions to clarify more:

If number 0 is a palindrome? or All one digit numbers are palindrome or not?
What about negative numbers? for example 121 is palindrome but what about -121? it will not be palindrome considering the negative sign.

Let's assume the interviewer clarify these questions like this:

All one digit numbers are not palindrome.
All negative numbers are not palindrome.

Now let's jump right into the solution.

First Technique

The first solution which comes to almost everyone's mind is:

Convert the number into string.
Reverse the string and compare both strings.

class Solution:
    def isPalindrome(self, x: int) -> bool:
        xString = str(x)
        return xString == xString[::-1]

This solution is actually correct but it requires some extra memory to create the string and the interviewer can put a restriction not to use any extra space. So in that case this solution won't be the best one to have.

Second Technique

In order to avoid the non-constant extra space usage what we can do is:

Revert the integer itself
And compare the integer with reverted one So how can we do that?

Let's try to see with an example 5445.
In mathematics we know we can get the last digit of a number by taking a 10 modulus so we keep taking the modulus and adding the number in reverted number and we will have the reverted number. And we will only revert positive numbers as we don't care about the negative ones in this case.

Python code looks like this to revert a positive number.

def revertNumber(x: int) -> int:
    if x < 0:
        raise ValueError('Only positive integers are allowed') 

    revertedNumber = 0

    while(x > 0):
        revertedNumber = revertedNumber * 10 + x % 10
        x = x // 10

    return revertedNumber

As we now have a function to revert the number so we can use this function to detect Palindromes.

def isPalindrome(x: int) -> bool:
    return x == revertNumber(x)

Final Approach

So now we have a solution which is more efficient than creating and reverting a string.

But.... we have a small issue with this problem if the reversed number is larger than int.MAX, we will hit integer overflow problem.

In order to avoid this situation we can change our solution a bit, instead of reversing the whole number we can just reverse the half of the number and compare it with the first half of the original number. For example:

5445, if we reverse the half number that would 54.
Now if we compare this 54 it's same as the first half of the number so this is a Palindrome.

def isPalindrome(x: int) -> bool:
    # Special cases:
    # As discussed above, when x < 0, x is not a palindrome.
    # Also if the last digit of the number is 0, in order to be a palindrome,
    # the first digit of the number also needs to be 0.
    # Only 0 satisfy this property.
    if (x < 0 or (x % 10 == 0 and x != 0)):
        return False

    revertedNumber = 0

    while(x > revertedNumber):
        revertedNumber = revertedNumber * 10 + x % 10
        x //= 10

    # When the length is an odd number, we can get rid of the middle digit by revertedNumber/10
    # For example when the input is 10501, at the end of the while loop we get x = 10, revertedNumber = 105,
    # since the middle digit doesn't matter in Palindrome(it will always equal to itself), we can simply get rid of it.
    return x == revertedNumber or x == revertedNumber//10

Complexity Analysis

Time complexity: O(log10(n)). We divided the input by 10 for every iteration, so the time complexity is O(log10(n))

Space complexity: O(1)

How you should review a PR

Tahir Raza — Wed, 06 Apr 2022 11:50:20 +0000

If your day-to-day job requires you to review the pull requests from fellow engineers and you find it difficult to review then try the approach defined in this post.

Reviewing a PR is actually can be a daunting experience and requires focus and time especially if you are reviewing a giant PR. Actually, before I share my thoughts on reviewing a PR, I would like you to understand how you should create one.

Whenever you are coding and about to create a PR, keep in mind how would you like to review a PR and try to create a PR the way you would like it.

In addition to that, I have some pointers for that.

1. - Always commit a meaningful chunk of the code.

Tip: If you forgot to commit a part of code or maybe some linter issue remained uncommitted, try not to create a separate redundant commit and squash that commit into the parent commit if it makes sense.

2. - Write an expressive message with your commits.

Avoid adding comments like fixed, fix the problem, etc, and try to be more expressive, your commit message should exactly express what you did in the code.

3. - Smaller the better

Never create giant PRs, smaller meaningful PRs are easy on the eyes.

4. - Create PR with descriptive titles and details.

5. - Try to add comments, and images on your PR whenever you feel it will make the reviewer's life easier.

For instance

If you committed a big composer.lock file you can add a comment about what exactly did you updated.
Maybe a new CSS change you did, try adding a screenshot of the change in views with before and after.
If you commit a change in a compressed file sometimes it's hard to see the actual change and you can add a comment with the actual diff.

If you keep creating PRs like this it will already improve your ability to review them.

Curiosity | A Valuable Trait for Software Engineer

Tahir Raza — Tue, 05 Apr 2022 13:28:48 +0000

Do you know Albert Einstein has a quote saying

I am neither especially clever nor especially gifted. I am only very, very curious. - Albert Einstein

This quote changed the way I think about learning new things. Now every time I want to or have to learn something new it's not a problem anymore because now I am actually really curious about things. And in my opinion Curiosity is a trait that every software engineer should have to grow as a professional.

The field of software development evolves at a really fast pace, every day there is something new to learn, a new update of the packages you are using, a new security vulnerability found which you have to patch. It's like a continuously erupting volcano of knowledge all around us.

For example, if you hear a word like Kubernetes and you are curious about it you can learn something new about it today. And if you are someone like me you will start by learning the meaning of the name and where it comes from and get familiar with it quickly.

Like I just found out the word "Kubernetes" comes from an old Greek word for “helmsman,” (someone who steers a ship, like a container ship) which also gives a hint about the ship wheel logo. So as the name suggests it is something that steers or in other words orchestrates and it's exactly what it does.

Kubernetes is an open-source container orchestration system for automating software deployment, scaling, and management. Google originally designed Kubernetes.

If you curious key term in this definition of Kubernetes leads to learn something new for example these words:

Open-source
Container
Scaling
Deployment

So what's the conclusion, if you are curious you can learn something new every day and you can have fun along the way so keep learning, and keep coding.