DEV Community: Farhan Yahya

xtensio - a new framework for browser extension development

Farhan Yahya — Sat, 19 Aug 2023 02:29:16 +0000

Are you curios? Check it out.
https://github.com/doc-han/xtensio

Tech interview & Social media presence 😡😡😡

Farhan Yahya — Wed, 21 Jul 2021 08:55:12 +0000

Like seriously why is everyone looking for social media presence along side resumes these days?
Do recruiters depend on it that much?
Example: I'm not a social media person, I love one-to-one interactions with people in my life, Quit using Facebook in 2015 which was the only social thing I used then.
Currently I only use WhatsApp which suits my definition of connecting with people.

But OMG, every job application page now has a required field for social media handles.

Can you check for prime numbers? - Primality Test

Farhan Yahya — Sun, 12 Jul 2020 11:08:29 +0000

This is one of the simple programs most developers really don't know how to go about. Just imagine getting such this question wrong at a coding interview while you aced all the language specific questions. That will be so sad.

In this post we'll look at how to check whether a value is prime or not using a primality test known as TRIAL DIVISION.

LITTLE EXPLANATION

Now, let's look at how one might go about this problem. Since a prime number is a number with just two divisors (1 and the number itself), a way to solve this problem is to try dividing the number by values between 1 and itself. If none divides perfectly then it's a prime number else it isn't. Hence, the code below

function isPrime(n){
  for(let i = 2; i < n; i++){
    if(n % i == 0) return false;
  }
  return true;
}

But guess what? the downside of this code is when it actually finds a prime number. Because to find a prime number the for loop has to run n-2 times. So let's say you are to check whether 13441 is a prime number, then that mean we need 13439 iterations which is too much and what if we are to check for 10⁶ numbers? that's lot's of time and computing power. Hence, we have a nice way of cutting off some of the work.

TRIAL DIVISION

With this method, we use a simple mathematical analysis to cut off most of the work that is to be done.

The idea is that: For any composite number(a composite number is the opposite of a prime number) the first divisor apart from 1 can be found between 1 and root of n (where n is the number to be tested).
eg. checking whether 100 is prime.
numbers between 1 and root(100) are 2,3,4,5,6,7,8,9
and fortunately 2 is a divisor of 100.
This method reduces the number of iterations exponentially making our code look like below

function isPrime(n){
  for(let i = 2; i*i <= n; i++){ // difference on this line i*i
    if(n % i == 0) return false;
  }
  return true;
}

So the logic is to iterate from 2 to root(n).
hence the condition i<=root(n),
squaring both sides will give the condition i*i<=n

And with this, to check whether 13441 is prime we only iterate 115 times instead of 13439 times.

Hope you learnt something today. Thanks

How to merge two Objects or Arrays in JavaScript

Farhan Yahya — Thu, 18 Jun 2020 06:57:09 +0000

So for a while now I've know the spread operator in JavaScript. I have been using it for while now but I never knew it worked for objects too.

Merging two Arrays

let a = [1, 2, 3, 4, 5];
let b = [6, 7, 8, 9, 10];
let c = [...a, ...b];
console.log(c);
// output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Merging two Objects

let a = {
  name: 'Han'
};
let b = {
  age: 98
};
let c = {...a, ...b};
console.log(c);
// output: {name: 'Han', age: 98}

I hope you also know now. Thanks for reading!

Is AI really intelligent?

Farhan Yahya — Tue, 05 May 2020 18:01:22 +0000

I'm a computer science student who started his journey in Machine Learning not long ago and as I kept moving on and studying some learning algorithms and many more this question came up to me. Is AI really intelligent?

What I think

For me, I'll say AI isn't that smart. Everything we've done is a nice try but we've gotten nowhere making computers smart.

AI to me is just an imitation game, why would I say this? You'll realize it more when you see some of the applications of AI in visual arts, music, and writing screenplays. It's unable to create but to imitate. It simply tries to find patterns in the data it's fed and the funny thing is that even if none exists it still finds you something.

The difference

When a human is fed with different paintings from different painters, he/she studies their individual artistic styles and uses it as a guide to creating something new but what AI will do is to just combine these paintings for you.

My definition of AI

Using mathematical formulas to find patterns in data and giving out an output that falls within that same pattern. Which humans can also do the hard way.

Hence, I'll say AI is cool but it's just an imitation game. What do you think?

Simple image lazy loading using JQuery

Farhan Yahya — Fri, 24 Apr 2020 13:51:52 +0000

Lazy loading is a technique where images are given a placeholder to be displayed while the actual image is loading in the background. The placeholder gets replaced with the actual image once it's done loading in the background.

Below is a series of fully explained code on how to implement lazy loading

Set the src attribute of your image to be the placeholder image

<img src="placeholder.png">

Give your image tag an attribute ref-src to with the url of the actual image you want to load

<img src="placeholder.png" ref-src="https://cdn.pixabay.com/photo/2019/12/30/14/13/snail-4729777_960_720.jpg">

write some javascript code to load the image in background and replace the placeholder after image has been loaded

// selecting image element to be lazy loaded
let elem = $("img");
//retrieving url from ref-data attribute
let url = elem.attr("ref-data");
//creating a new image object
let loadingImage = new Image();
//this function is called when the image object
//is done loading it's image
loadingImage.onload = function(){
    //src attribute of elem is being replaced
    //with that of loadingImage because its done loading
    elem.attr("src", url);
}
//the url from elem has been assigned
//to the new image object for loading 
loadingImage.src = url;

An with this code you've implemented lazy loading. These days most developers ignore the use of spinners as placeholders but rather prefer a grey looking shadow of the image.

Lazy loading all images on your site

To lazy load all images on your website, I have this simple script for you to use. Try understanding the code below because it's very similar to the one above.

let imgs = $("img");
for(let a=0;a<imgs.length;a++){
  loadImage(imgs[a]);
}
function loadImage(elem){
  let url = $(elem).attr("ref-src");
  let newImg = new Image();
  newImg.onload = function(){
    console.log("done loading");
    $(elem).attr("src", url);
  }
  newImg.src = url;
}

Voilà! all images on your site will be lazy loaded but remember to always put your placeholder in the src section and the image you want to load in the ref-src attribute like below

<img src="placeholder here" ref-src="actual image here">

What is your first surprise in 2020?

Farhan Yahya — Wed, 08 Jan 2020 01:48:12 +0000

I fell from a scooter today and I'm hurt. From face, fingers to legs. Not really severe but these fingers will surely type again. Alhamdulillah 😊

Binary Exponentiation

Farhan Yahya — Mon, 06 Jan 2020 10:01:31 +0000

Binary exponentiation is a simple technique used to find the value for aⁿ in O(logn) multiplications instead of the naive way which is O(n) multiplications. First, let's have a look at the naive way then this way.

The naive way

From mathematics, aⁿ is expressed as a multiplying itself n times. Hence a naive function for solving this will be like below.

int pow(int a, int n){
  int ans = 1;
  while(n--){
    ans *= a;
  } 
  return ans;
}

This is quite simple but we will want to reduce the complexity of this function and that is where binary exponentiation comes in.

This way(Binary Exponentiation)

In this method, the work is split into the binary representation of the exponent which reduces the computation to O(logn).

Example

Naive: 3¹³ = 3 * 3 ... 3
This way: 3¹³ = 3¹¹⁰¹ = 3⁸ * 3⁴ * 3¹
Implementing an algorithm for this is very simple. intead of looping n times we rather loop through the bits which is logn times. To get our solution, we then find the powers at which a bit is set just like the example above. Because we are using the binary presentation of n the power at a set bit will be the square of the previous set bit.
That is:
3¹ = 3
3² = (3¹)²
3⁴ = (3²)²
3⁸ = (3⁴)² ...

So with this, we just find the product of the powers set in n.

Code for this way

int pow(int a,int n){
  int res = 1;
  while(b){
    if(b&1){
      res *= a;
    }
    a *= a;
    b >>= 1;
  }
  return res;
}

The above code computes in O(logn) which is better than the naive way which computes in O(n)

My only 2 plans for 2020 😖

Farhan Yahya — Sun, 05 Jan 2020 07:09:07 +0000

Everyone does it

Whenever a year begins, one of the things you will hear here and there is a plan for the year or a todo list. This has been what I've been hearing from most of my friends but funny thing is that I never had one. All I knew was that it's a new year and life still goes on but some time ago I realized that this thing kind of help. Because I've been passing through the years just like that.

When I decided to do it

Hence, I decided to start using a plan or a todo list and the year was 2019 😅😅.
In December 2018 I has sat down and listed almost everything I wanted to do in 2019. It was an interesting list that I was very passionate about but I ended doing just one throughout the whole year. I touched some pieces but never completed them. So this year I came with a new strategy to make sure I'm able to complete the list.

What I realized

At the end of 2019, I realized something about me that might apply to you too.

My list for 2019 was too long.
It wasn't a year based todo list. It was what I wanted in life.
I didn't weight the time for completion of each task before listing them.
I always thought there is enough time in a year and even when In September I still see more time.

And these are the reasons I'm going for just 2 plans this year. These plans are to help me in my subsequent plans.

My 2 plans

These plans are very simple than you might have been guessing.

I want to learn Machine learning(and all the math involved) and improve my Algorithms this year.
I need a source of income.

The second point is very important to me because I'll be 20 this year and I still rely on my parents. Over here it's quite normal and happens all the time because of the high unemployment rate but I'm not okay with that. Hence this year, I''m going to try a variety of stuff from Youtube to small Saas software. I love open source tho

Please help with your ideas in the comment box

Did you nest your loop perfectly? Let's check it out.

Farhan Yahya — Thu, 31 Oct 2019 19:21:03 +0000

Have you ever taught of how loops hurt the execution time of your code? if not then I think you should begin to worry about all these petty stuff when writing programs.

Let's see how we can make your loop better. Let's say we have an array A of size 9 and an array B of size 7, and our goal is to find the total sum when every single element in A is multiplied to every single element in B. Our code will be like below.

let a = [1,2,3,4,5,6,7,8,9];
let b = [1,2,3,4,5,6,7];

let sum = 0;

for(let i = 0;i<a.length;i++){ //looping 9 elements
    for(let j = 0;j<b.length;j++){ //looping 7 elements
        sum += a[i]*b[j];
    }
}
console.log(sum);

Wait, let's analyze this loop. Let's assume that a single iteration takes a second. Then that means that the outer loop which loops through array A(9 elements) will take 9s to run and the inner loop that loops through array B will take 7s to run. But because the inner loop is inside another loop, and the inner loop is called 9 times, the whole code will then take 9+(9x7) seconds to run. Meaning it takes our code 72s(1m 12s) to run.

How do we reduce the execution time?

As simple as it is, let's just make sure to always nest the loop that iterates the most. In the example above, instead of nesting the loop that goes through B, we would rather nest the loop that goes through A.

let a = [1,2,3,4,5,6,7,8,9];
let b = [1,2,3,4,5,6,7];

let sum = 0;

for(let i = 0;i<b.length;i++){ // looping 7 elements
    for(let j = 0;j<a.length;j++){ //looping 9 elements
        sum += b[i]*a[j];
    }
}
console.log(sum);

Then, our total time taken instead of being 9+(9x7) seconds will be 7+(7x9) seconds which is 70s(1m 10s).

Hence time saved is 72s - 70s which is 2s. Imagine the time saved in computations with large array sizes. Hope you liked it

Computer Science for all

Farhan Yahya — Fri, 20 Sep 2019 15:56:52 +0000

Hi, I’m Han.

I’m a computer science student and I will like to share what I learn at school in brief writings so that non-computer science developers or self-taught developers can also have a brief knowledge of some of the things we learn.

I believe strongly that in order for one to understand something very well, he/she has to share the knowledge and also learn from others. Because of this, I joined a STEM education organization (EliTe education) way back in 2017 while I wasn’t yet in the University and it has helped me a lot.

If you are interested in this journey, then tighten your seatbelts and let’s get going.

In need of cool ideas

Farhan Yahya — Thu, 19 Sep 2019 19:28:33 +0000

I was walking down the stairs when my computer science department president stopped me and asked me to help him come up with cool ideas on programs or events for the semester. Our department is very boring and we want to make it feel as it's supposed to. Please I need suggestions and I appreciate all your contributions. THANKS