Execute https://wa.me/91xxxxxxxxxx URL in an Android App to Chat with non contact numbers

If you link your google chrome profile with your whatsapp account..

then while in chrome open the URL https://wa.me/91xxxxxxxxxx

the xxx being an unknown mobile number.. You can rest assured that 

you can chat with that person in WhatsApp without storing the number.

The URL will be executed in an Android App.

After you launch the app..

you can type the number.. no extra permissions needed.

Just press ENTER and off you go with your chat.

Here is the repo in case you are interested: Link

Its created in Android Studio using kotlin language.

Loom video: https://www.loom.com/share/762d9d55fa6b420eabbc78cec0ad9bda?sid=c3a1571b-c746-4993-a39d-45ab511501d4

Full Stack Development in MERN Stack

 Hello,

Tumultus ride it has been as always. Its June,2nd 2025 and as even semester of Academic year 2024-25 is reaching its end, my college went for peer review by NBA and results are awaited. Suffice to say we have learnt what it entails to make graduates with all attributes that we claim they possess.

I(https://jyothyit.ac.in/faculty/mr-mukesh-kamath-bola/) was called upon to handle the subject FSD with Mern stack. It was very tough esp when I didn't know MongoDB that well, let alone expressjs or webpack and modularization.

Here is the manual of our lab that was the outcome of the course.  

FSD-BIS-601-MANUAL

Here are some projects that I demonstrated: https://github.com/bmkamath2000/React-Projs

Dunder / Magic Methods in Python like __init__()

 Tech with Tim in his python video on Dunder methods in python speaks about

1) __init__() method is a constructor                                

class Rect():

    def __init__(self,x,y):

        self.x = x

        self.y = y

        print("Called __init__ with param %s, %s" % (x,y))

Rect(2,3) => calls __init__ method.

2)  + method is same as __add__()

str1 = "hello"                          

str2 = "world"

new_str = str1 + str2

same_str = str1.__add__(str2)

print(new_str)

print(same_str)

3) __length__() is invoked when len(object) is called                  

str1 = "hello"

str2 = "world"

str1_length = len(new_str)

str2_length = len(same_str)

print(str1_length, str2_length)

4)  __add__(self, oper): is invoked on + operator

     __str__(self): is invoked when the object is printed

class Counter():

    def __init__(self):

        self.value = 1

    def count_up(self):

        self.value += 1

    def count_down(self):

        self.value -= 1

    def __str__(self):

        return f"Count=%s"% self.value

    def __add__(self, oper):

        return self.value + oper.value

count1 = Counter()

count2 = Counter()

count1.count_up()

count2.count_up()

print(count1, count2)

print(count1 + count2)

5) __repr__()   - representation

6) __sub__(),    --subtraction

   __mul__(),      -- multiply

  __truediv__()    -- division

7)__lt__()      --Lessthan, 

   __gt__()     --GreaterThan, 

   __eq__(),    -- Equalto    

  __gte__()  -- Greater than equal, 

   __lte__()  -- Less than equal,

   __ne__()  - notequal

8) __getitem__() in lists obj[item] useful for indexing,

   __setitem__() in lists obj[index]= value,

   __delitem__()in lists del obj[index],

I intended to try out all the methods but lack of time is making me post faster

Python Decorators

These features of python are not in any order of importance as such.

I chanced upon a youtube video where "the python dude" was explaining decorators.

It seems like in python we can pass function names as parameter.

Also the passed function can be called from the called function.

Hence our code becomes more useful and more difficult to understand.

import time

def measure_time(func):

    def wrapper():

        start = time.time()

        func()

        end = time.time()

        print(f'Execution time : {end - start} sec')

    return wrapper

@measure_time

def morning():

    print("Good morning")

morning()

Output:

pythonprgms>python pythonprgm5.py 

Good morning

Execution time 0.000936 sec

A similar program with two decorator per function morning is possible:

#It happens because the decorator runs the function immediately.

# The wrapper prevents that and ensures it only runs when you call it.

import time

def measure_time(func):

    def wrapper():

        start = time.time()

        func()

        end = time.time()

        print(f'Execution time : {end - start} sec')

    return wrapper

def greeting(func):

    def wrapper():

        print(f'Hello,')

        func()      

    return wrapper

@greeting

@measure_time

def morning():

    print("Good morning")

morning()

Output:

pythonprgms>python pythonprgm6.py Hello, Good morning

Execution time 0.000936 sec

Similar changes post we can pass arguments to morning function but decorators too need to 

pass same arguments.

# *args , **kwargs

import time

def measure_time(func1):

    def wrapper(*args , **kwargs):

        start = time.time()

        func1(*args , **kwargs)

        end = time.time()

        print(f'Execution time : {end - start} sec')

    return wrapper

def greeting(func2):

    def wrapper(*args , **kwargs):

        print(f'Hello,')

        func2(*args , **kwargs)      

    return wrapper

@greeting

@measure_time

def morning(name):

    print("Good morning %s" % name)

morning("John P Diaz")

Output:

pythonprgms>python pythonprgm7.py Hello, Good morning John P Diaz Execution time : 0.0 sec

Python Dictionaries

 A dictionary in python can contain name value pairs. Like

thisdict = {

    "name" : "Shiva",

    "gender" : True,

    "age" : 45,

}

where thisdict contains name, gender and age of string, boolean and int data type.

On purpose I have created another dict with a JSON as a value of a name-value pair.

thisdict = {

    "name" : "Shiva",

    "gender" : True,

    "age" : 45,

    "assets-json" : {

        "net-worth": 1000000,

        "house-type": "flat",

        "address": ["J P Nagar 5th Ph",

                    "Bangalore",

                    "560034"]

    }

}

I have made use of this dictionary structure in a program which

a. finds the length of the dictionary

b. prints the name, gender and age

c. prints the net-worth of the individual in the dictionary object.

thisdict = {

    "name" : "Shiva",

    "gender" : True,

    "age" : 45,

    "assets-json" : {

        "net-worth": 1000000,

        "house-type": "flat",

        "address": ["J P Nagar 5th Ph",

                    "Bangalore",

                    "560034"]

    }

}

thatdict = {

    "name" : "Harish",

    "gender" : True,

    "age" : 54,

    "assets-json" : {

        "net-worth": 10000000,

        "house-type": "Individual House",

        "address": ["Jayanagar",

                    "Bangalore",

                    "560045"]

    }

}

def length_of_dict(dict_param):

    return len(dict_param)

def display_dict(dict_param):

    print("this dict is of %s" % dict_param["name"])

    gender = "male" if dict_param["gender"] == True else "female"

    print("Age = %s \nGender= %s" %(dict_param["age"], gender))

    print("Net Worth:%s" % dict_param["assets-json"]["net-worth"])

if __name__=="__main__":

    print("Length of thatdict:",length_of_dict(thatdict))

    print("Length of thisdict:",length_of_dict(thisdict))

    display_dict(thatdict)

    display_dict(thisdict)

Output of the program:

Length of thatdict: 4

Length of thisdict: 4

this dict is of Harish

Age = 54

Gender= male

Net Worth:10000000

this dict is of Shiva

Age = 45

Gender= male

Net Worth:1000000

Python Lists

 In Python, a list is a built-in dynamic sized array (automatically grows and shrinks). We can store all types of items (including another list) in a list. A list may contain mixed type of items, this is possible because a list mainly stores references at contiguous locations and actual items maybe stored at different locations.

• List can contain duplicate items.
• List in Python are Mutable. Hence, we can modify, replace or delete the items.
• List are ordered. It maintain the order of elements based on how they are added.
• Accessing items in List can be done directly using their position (index), starting from 0.

nested lists in python : matrix = [

    [1, 2, 3],

    [4, 5, 6],

    [7, 8, 9]

]

# Access element at row 2, column 3

print(matrix[1][2])

Another program to find pair of numbers in a sorted array that sum to a value(target):

def pair_sum_sorted_all_pairs(arr, target):

  """

  Finds all pairs in a sorted array that sum to a given target.

  Args:

    arr: A sorted array of integers.

    target: The target sum.

  Returns:

    A list of tuples representing the pairs.

  """

  result = []

  left, right = 0, len(arr) - 1

  while left < right:

    current_sum = arr[left] + arr[right]

    if current_sum == target:

      result.append((arr[left], arr[right]))

      left += 1

      right -= 1

    elif current_sum < target:

      left += 1

    else:

      right -= 1

  return result

if __name__=="__main__":

    arr = [1, 2, 3, 4, 5, 6, 7]

    target = 8

    print(pair_sum_sorted_all_pairs(arr, target))

When we run this program here we get following output:

C:\Users\kamat>python untitled123.py

[(1, 7), (2, 6), (3, 5)]

Python - Basics

I have written three python programs in increasing order of complexity.

First one is:

x=int(input("Enter a number"))

y=int(input("Enter another number"))

z=int(input("Enter third number"))

sum=x + y + z

print(sum)

The program reads three numbers (Integers) and finds their sum

class simple:

    def simple_one():

        print("Hello mukesh")

        print("Hello manjunath")

if __name__=="__main__":

    simple.simple_one()

This next program creates a simple class and calls a method on the class object.

The if statement equates __name__ to "__main__" and executes the method if so.

class simple():

    def __init__(self,name,age):

        self.name = name

        self.age = age

    def simple_one(self):

        print("Hello %s %s"%(self.name,self.age))

if __name__=="__main__":

    s = simple("mukesh",45)

    s.simple_one()

This next program above instantiates an object of

class simple by calling its constructor. Then a

method simple_one() on the created object.