Forem: Mohammed Ashfaq Ashar

Migration of Cypress 12.7 from Cypress 9.7

Mohammed Ashfaq Ashar — Sun, 12 Mar 2023 05:35:22 +0000

Hi all,
I have came up with new interesting topic under cypress automation which is migration of cypress from older version to latest version. Currently i am using cypress 9.7 for my testing purpose, but after going through their new version released, i just migrated to their new latest version which is cypress 12.7. After successful migration, i was able to encounter certain failures of my test files, since it is not compatible with latest version.

So today my article will give a brief idea about latest cypress version, cool features available, limitations etc. And especially, I wanted to discuss about certain failures I encountered in my current spec files after migration and solution I have applied to resolve them.

Without any further delay, Let's dive into this cool concept

What's Cypress 12

The main feature that was introduced in cypress 12, experimental use of origin and session that was introduced in previous version was removed. You all may wonder what is the origin?. And what is the purpose of using origin in cypress automation script. cy.origin() allows you to visit another domain, driver the browser and return back to the application.

Crossing origins is super common with sites that use third-party authentication. It prevents the tester from writing the automation script, in the way how the real application is operated. With the cypress 12, cy.session() made generally available which is out of experimental status. Therefore experimentalSessionAndOrigin can be safely removed from configuration

Cool features compared to Cypress 9.7

Test isolation are true by default
The Fix for Dreaded Detached DOM Errors
Added official support for Vite 4 in component testing
Experimental memory management to improve memory management of chromium family
cy.getallcookies() and cy.setallcookies() were added to get and clear cookies for all browser cookies across any domains
cy.getalllocalstorage() was added to get localStorage data for all origins with which the test has interacted
Further improved bundling in the binary to reduce startup and unzip time
Can have single session and origin if we try to have them same in multiple testcases
Next.js v13 was supported
Component testing is now beta and much more ....

Limitaion on Cypress 12 with 9.7

there are several limitiations available in cypress 12, but I have pointed out some main limitations

Run all specs was removed from cypress 9.7 onwards. Then on later version, they introduced Run all specs under experimental mode
Plugin folder no longer available. Therefore setupNodeEvents(on, config) under e2e section which is under cypress.config.ts.
.within() now throws an error when given more than one element as the subject from cypress 12 onwards

So now the time has come to migrate cypress 9.7 to cypress 12
To make it much more interesting, i will guide you step by step

Step 1
In Visual Studio Code, go to package.json file. Then search for the place “cypress” under “devdependencies”. Change it’s version by simply adding the version number infront of cypress as shown in figure below

Open the terminal and type the command below
npm update

Step 2
As next step, run the command
npx cypress open

Once you run this command, you will be directed to the new UI on migration guide. Depending on the version migration, steps will be shown. So it’s just renaming and conversion. It will automatically done by just clicking “Next button”.
Mostly it will be shown with 3 steps migration

Step A : Renaming the spec file extension to cy.js or cy.ts depends upon typescript or javascript
Step B : Renaming of cypress/support/index.js to cypress/support/e2e.js

The above 2 steps are not give a great impact to our code. But the next step is really important which may cause failure to all your spec files to run. After completing this step, you need to identify the root cause of the failure and fix it.

Step C : Migration of cypress.json file to cypress.config.js / cypress.config.ts

This step will convert the json file to class file. If you able to encounter any failure on conversion, try to fix it manually.

Congratulations guys!!!!🎉 🥳 👏 . We have now sucessfully migrated to latest version. If you are new to cypress testing, it's totally fine you to write your automation script. But if you already have certain important specs and if they not compatible with cypress 12, then it's going to be a big problem. So you need to fix them as well. Some main problems I have encountered as below. I would like to provide solutions for them as well

Problem 1
.within() now throws an error when given more than one element as the subject, eventhough we have mentioned under conditions

As a solutions, we can introduced first() or last() only if 2 elements are found. But if you have multiple elements, the best option, just obtain that web element id, class name or any unique identifier and use them

Problem 2
There are some occasions when we try to have the same sessions and origin in multiple “it” blocks of the same spec file. Latest Cypress removed the experimental session and origin. Therefore we can have them in a single “it” block, so it will automatically applied to other “it” blocks. If we need to have different sessions or origin in same it blocks, so we can introduce them as required

And that's it.

I hope this article will be really helpful if you are planning to migrate your automation script to latest version. If you have any further doubts on migration, drop your comments below, I am glad to support you all

Thank you

Social Login using Cypress 12.7.0

Mohammed Ashfaq Ashar — Sat, 11 Mar 2023 08:48:08 +0000

Hi guys !!!!
I am writing this after a long time. Today i am going to share an interesting topic under cypress automation tool, which is social login. Normally we do sign in just by entering the username and password without signin using any sort of social authentication such as google, github, microsoft etc.

So, today I am here to share, how to perform social login using automation tool which is cypress. Let move step by step

Step 1
Create the cypress project, by entering following commands

npm init
npm install cypress --save-dev
npx cypress open

Step 2
Enter the below line of code under cypress.config.js/ts. This code will check whether Cypress will search for and replace obstructive code in third party .js or .html files. (This piece of code prevent you from displaying 403 error page of Google after entering credentials and to dive into microsoft login page to enter credentials)

experimentalModifyObstructiveThirdPartyCode: true,

Step 3
Now you have successfully created the cypress project. Now it's time to create social login automation script using cypress. In here, i will guide on create social login of google, github and microsft. we can perform same code for facebook sign in as well
Without further delay, Let's dive in automation script

describe("1.1- Sign in with Google",
    function () {
    it('1.1.1- Sign in with Google Sample Test', () => {

    logIntoGoogle("test98@gmail.com","test@1234")
    });
    });


function logIntoGoogle(username, password) {

    Cypress.on(
        'uncaught:exception',
        (err) =>
          !err.message.includes('ResizeObserver loop') &&
          !err.message.includes('Error in protected function')
      )

  cy.visit('https://www.sample.lk/')
  cy.contains("Login").click()

  cy.get('[class="btn--1gFez tertiary--5kHib small--1MQ15 button--juoup gtm-google-login"]').click();



  cy.origin(
    'https://accounts.google.com',
    {
      args: {
        username,
        password,
      },
    },
    ({ username, password }) => {
      Cypress.on(
        'uncaught:exception',
        (err) =>
          !err.message.includes('ResizeObserver loop') &&
          !err.message.includes('Error in protected function')
      )

      cy.get('input[type="email"]').type(username, {
        log: false,
      })
      // NOTE: The element exists on the original form but is hidden and gets rerendered, which leads to intermittent detached DOM issues
      cy.get('[class="VfPpkd-LgbsSe VfPpkd-LgbsSe-OWXEXe-k8QpJ VfPpkd-LgbsSe-OWXEXe-dgl2Hf nCP5yc AjY5Oe DuMIQc LQeN7 qIypjc TrZEUc lw1w4b"]').click().wait(4000)
      cy.get('[type="password"]').type(password, {
        log: false,
      })
      cy.get('[class="VfPpkd-LgbsSe VfPpkd-LgbsSe-OWXEXe-k8QpJ VfPpkd-LgbsSe-OWXEXe-dgl2Hf nCP5yc AjY5Oe DuMIQc LQeN7 qIypjc TrZEUc lw1w4b"]').click().wait(4000)

    }
  )

  cy.get('.login-icon-container--3oQMU > .justify-content-flex-start--1Xozy > .header-link--woAbP').click();
  cy.contains("Test Sample")
}

Now let me give the brief idea on this code structure. In here we are performing google sign in for a sample application. Initially it visits the application and clicks the login button. As next step, it will dive into login page. We can observe multiple social login options are available for user to choose. In this case, we are choosing google sign in. Once "sign in with google" is clicked, it will direct you to another page which is "https://accounts.google.com", to enter our credentials. But we can observe, intially we are in one url, and now we are in different url, this situation we called Multi-domain testing. To handle this multi-domain testing, we wrap the new different url under command cy.origin(), which you can observe on the above code structure. Then once we entered to new url, we enter the username and password. Also since we move from one domain to another domain, we may able to get uncaught error exception failure. To handle them, we use

Cypress.on(
        'uncaught:exception',
        (err) =>
          !err.message.includes('ResizeObserver loop') &&
          !err.message.includes('Error in protected function')
      )

the above code within origin. After successful login, it will automatically redirect you to your desired website, which you mentioned under cy.visit(). Also, I have added a small piece of code after redirecting to verify whether the desired page has appeared

Step 4
Now we have done with all the steps. Time has come to check whether the above steps works fine without failure. To verify it, you just need to run the below code in your terminal

npx cypress open

Let me give the code structure for github signin and microsft signin as well

describe("1.1- Sign in with Google",
    function () {
    it('1.1.1- Sign in with Google Sample Test', () => {
        logIntoMicrosoft("test98@gmail.com","test@1234")




    });
    });


    function logIntoMicrosoft(username, password) {
        cy.visit('https://www.sample.lk/')
        cy.contains("Login").click()
        cy.get('[data-testid="login-page-sign-in-with-microsoft"]').click()



        cy.origin(
          'https://login.microsoftonline.com',
          {
            args: {
              username,
              password,
            },
          },
          ({ username, password }) => {
            cy.get('input[type="email"]').type(username)
            cy.get('input[type="submit"]').click()
            // cy.get('input[type="password"]').type(password, {
            //   log: false,
            // })
            // cy.get('input[type="submit"]').click()
            // cy.get('#idBtn_Back').click()
          }
        )



        cy.origin(
            'https://login.live.com',
            {
              args: {
                username,
                password,
              },
            },
            ({ username, password }) => {
              //cy.get('input[type="email"]').type(username)
              //cy.get('input[type="submit"]').click()
              cy.get('input[type="password"]').type(password, {
                log: false,
              })
              cy.get('input[type="submit"]').click()
              cy.get('#idBtn_Back').click()
            }
          )

      }

The above code structure for microsoft signin. Here, we need to go to 2 origin, one to enter username and another origin to enter password.

Finally, let's go to github signin

describe("1.1- Sign in with Github",
    function () {
    it('1.1.1- Sign in with Github Sample Test', () => {

        cy.visit('https://www.sample.lk/')
        cy.contains("Login").click()
        cy.get('[data-testid="login-page-sign-in-with-github"]').click()


        cy.origin('https://github.com', () => {

        Cypress.on('uncaught:exception', (err, runnable) => {
            // returning false here prevents Cypress from
            // failing the test
            return false
        })

            cy.get('[id="login_field"]').type("test98@gmail.com")
            cy.get('[id="password"]').type("test@1234");
            cy.get('[class="btn btn-primary btn-block js-sign-in-button"]').click();

            Cypress.on('uncaught:exception', (err, runnable) => {
                // returning false here prevents Cypress from
                // failing the test
                return false
            })


        })

        cy.wait(10000)




    });
    });

I hope this article will be really helpful for you all if you planning to social authentication using cypress automation for your testing.
If you have any questions, feel free to drop your comment, so then i can able to help you

Thank you

Reduction of environmental pollution caused through vehicles using Graph theory

Mohammed Ashfaq Ashar — Thu, 29 Apr 2021 08:36:08 +0000

Introduction

In this modern era, vehicles are heavily used in all developed and non-developed countries. Day by day, usage of vehicles increased. So it causes several adverse effects to nature. One of the worst effects is Air pollution. Exhaust from vehicles is a significant wellspring of open-air contamination around the world
We simply called the pollution caused by the vehicle “vehicle pollutions”. Vehicular contamination is the presentation of unsafe material into the climate by engine vehicles. These materials, known as contaminations, have a few awful impacts on human wellbeing and the biological system. Transportation is a significant wellspring of air contamination in numerous nations throughout the planet because of the great number of vehicles that are accessible on the streets today. An expansion in buying power implies that more individuals would now be able to manage the cost of vehicles, which is awful for the climate. The air contamination from vehicles in metropolitan territories, especially in large urban areas, has become a major issue. The contamination from vehicles has started to tell through indications like severe cough like asthma, migraine, queasiness, disturbance of eyes, different bronchial and perceivability issues.
Ozone, Particulate matter, Nitrogen oxides, Carbon monoxide, Sulphur dioxide, and hazardous air pollutants are some of the main ingredients of vehicular pollutions.
Due to above such mentioned issues, there is a very simple and clear solution for it. Dijkstra's Algorithm is coming under graph theory that is normally used to find the shortest path between two points.
By applying this practical solution, to this problem, we are successfully able to get rid of these issues. Overall, we can observe that problem is mainly due to the traveling of vehicles worldwide without having a proper and shorter path to reach the destination. So due to it, there will wastage of fuels at the same time, pollutants are released to the environment. By having a shortest between the starting point and ending point, we could able to minimize these issues. Therefore Dijkstra's Algorithm helps us to solve this issue. This algorithm continuously go through all the possible path and get the best shortest path between two points which helps to preserve fuels and minimize the release of pollutants

Methodology

In this article, Dijkstra's Algorithm has been used to solve the problem that has already been mentioned. If the vehicles traveled so long without any proper and shortest route rather than regular route, there are high chances of getting pollution. The shortest routing helps for the least pollution.

The following model represents a simple road network model
with starting point and ending point

G = (V, E) as per the definition of a graph. “V” represents a set of vertices and “E” represents a set of edges. So the road network has to mapped to graph inorder to have the least pollution to environment and also preserve the fuels. Therefore vertices, we simply say nodes are compared to cities, and edges were compared to road. And also the values that written on top of the edges are simply said as “weights” according to graph theory. Therefore such graphs are considered to be weighted graphs. These weights are considered the distance between two cities.

For example, we simply set “C” (red dot) as a starting node. Therefore we make as distance 0 while others to infinity as step 1

Then we can see the neighbor nodes of “C” which are “A”, “B” and “D”. Since “C” is starting node, the weights of “A”, “B” and “D” as follows
A = 0 + 1 = 1
B = 0 + 7 = 7
C = 0 + 2 = 2

So now we can observe the shortest path among all the “A”, “B” and “D” is “A” where C – A is 1.
So now the red dot moves to “A”. from “A”, it is observable that only “B” is neighbor since “C” already visited. Therefore the new weight of “B” is 1 + 3 = 4 which is less than the previous 7.

As a result, we could recursively perform the same procedure inorder to get the least path or weight for all the vertices. The final result would be as follows

so the above weights which are compared with distances are given at top of nodes by taking “C” as a starting point. Inorder to clarify further, we could see on top of “B”, there is a number 4, which represents the shortest path from “C”, where “B” is the final destination. This means the path is, C A to B is1+3=4
But if we consider a path as
C to D to E to B which is 2+7+1=10 which is much more long compared to previous, where there will high wastage of fuels and a high amount of pollutants emission to the environment. Therefore Dijkstra's Algorithm solves this problem by finding the shortest path from starting point to all other points in order to reach the final destination with the least pollutants released to the environment.

Conclusion

In this article using the concept of graph theory which is Dijkstra's Algorithm, we tried to solve the problem caused due to unnecessary routes used to reach the final destination which results in environmental pollutions and high fuel consumption.
Therefore as a responsible individual, it is a must to protect nature and preserve fossil fuels for the future generation

Kruskal's and Prim's algorithm

Mohammed Ashfaq Ashar — Wed, 13 Jan 2021 14:03:33 +0000

Today I have come with an interesting tutorial which is Krushkal’s and prim's algorithm. First of all, I would like to explain to you all about the definition of Data structure and Algorithm. The data structure is considered as the way to organize and store data and information in an efficient way such that you can access them quickly, whereas algorithms are considered as the steps that have to be taken to get the expected output from a given set of inputs.
According to research, many computer science students have facing difficulties to understand Data structure and Algorithm, due to the complexity of the subject. Even though it is hard to understand, it plays a major role in the IT industry.
So, in today’s blog, I would like to give you a brief and clear explanation of Kruskal’s and Prim's algorithm which is widely used in finding a minimum spanning tree. I hope you all have a better foundation in trees and minimum spanning trees. However, I would like to explain this algorithm with all the basic explanations of trees and minimum spanning trees from scratch.
Now let us begin

What are trees?

From the above figure, I hope you have got some ideas regarding the definition of a tree. Simply, we can say the tree is a collection of edges and vertices. There are several types of trees where each tree has its unique functionalities. Some of the trees are

Binary tree
Red black tree
Binary search tree
AVL tree
B tree

and so on.
As I mentioned before, trees are classified into a variety of types due to their functionalities. Some of the functionalities are

Used to hierarchical data
Used to implement expression parsers and expression solvers.
Used the Memory management subsystem of the Linux kernel to search memory regions of processes during preemption.

and so on.

I hope now you have got a better foundation about the definition and uses of Trees. Now let us see what spanning and minimum spanning tree
Initially let us look at spanning tree

What is a Spanning tree?

As simply we can say that a spanning tree is a subgraph of an undirected graph, where it consists of all the vertices with a minimum number of edges.
Let's take an example,
Here there is an undirected graph, we have to find the spanning tree of it.

So initially, we have mentioned all the vertices. Then we have connected them by edges, such that the number of edges is minimum. And here, since it is a tree, there should be any cyclic formation. So as a final output, the spanning tree will look like

There may be several spanning trees we can get from a given undirected graph. As to make this simple, I have given only one spanning tree.

This is the complete idea of a spanning tree. I hope you have got some idea about the spanning tree. As a next step, lets us look at the minimum spanning tree, where we are going to learn about Kruskal’sand prim's algorithm

What is the Minimum spanning tree?

The minimum spanning tree is a spanning tree, where the addition or the sum of the weight of the edges should be minimum.
I hope you all are wondering, why we have to find the minimum spanning tree, and what is the use

Ok, to clear this issue I would like to give you some practical usage of minimum spanning tree.
It is heavily used in

Network design such as telephone and cable networks.
Traveling salesman problem
Cluster analysis
Entropy-based image registration and so on

Now comes, a big question

How to find a minimum spanning tree from a given undirected graph?
Is there any technique for it?
How to apply it?

Here the place where Kruskal’s and prim's algorithm comes into play. From all the above information you have got some solid idea about trees, spanning trees, minimum spanning trees, and their applications. Now let us discuss this algorithm

How to find Minimum Spanning Tree?

We have two approaches to find the minimum spanning tree. Simply, these 2 approaches are algorithms. They are

Kruskal’sAlgorithm
Prim's Algorithm

Here I am going to explain the above two algorithms thoroughly with example.
Let's look at our 1st algorithm which is the Kruskal's algorithm

Kruskal’s Algorithm

This is one approach that we can use to find the minimum spanning tree.
I don’t like to provide algorithm at once so that you won’t get a better understanding. Rather, I would like to provide you with a pictorial example so that you will have a complete picture of this algorithm very clearly

Let’s look at our example

Find the minimum spanning tree of the graph below

Step 1

Arrange all the edges in ascending order according to their weight( the value is written on top of the edge). Src means starting vertex and Dest means ending vertex

Step 2

Now we shall pick the shortest weight out of all

Step 3

Keep in mind, there should be no cycle. So we pick the next short one which is 8 - 2

Step 4

Pick next short one 6 – 5

Step 5

Pick the next short one which is 0 – 1

Step 6

Pick the next short one which is 2 – 5

Step 7

Now the problem comes. The next short one is 8 – 6 which contains a cycle if we add. So we simply discard it

Step 8

Pick the next short one which is 2 – 3

Step 9

Pick 7 – 8. It will result in a cycle. So simply remove it

Step 10

Pick the next short one which is 0 – 7

Step 11

Pick 1 – 2. It results in the cycle. So discard it

Step 12

Pick the next short one which is 3 – 4 This is the final output. Because all the vertices are present in it and also some of the weight is minimum.

Now we shall have a look into the Prism algorithm to find a minimum spanning tree

Prim's Algorithm

This is another approach that we could follow to obtain the minimum spanning tree.
Let’s take the previous example here itself

I hope that you can remember the above diagram. This is the same one we have taken before for Kruskal’s algorithm
Let’s see how to find the minimum spanning tree by using this approach

In this algorithm, we are free to select any vertex as you wish. So to make this algorithm simpler, I am going to select the starting vertex “0”

Step 1

Select the node/ vertex as the starting node (“0”) and color with green. Then find all the adjacent vertex of it. Put their weight on the adjacent nodes at the same time make “0” as the weight of the starting node.

Step 2

We can observe that weight of 0 – 1 is “4” while 0 – 7 is “8”. We have selected the lowest weight edge, which is 0 – 4. Since we already found the adjacent node of “0”, now we have to find all the adjacent nodes of “1” and connect it.

Step 3

We can observe that vertex “7” and vertex “2” have the same weight. We can select any node as per our wish. I am going to select vertex “7” and color it green after finding all the adjacent vertex of “7” and connecting them

Step 4

Now we can observe that vertex “6” has the lowest weight among vertex “8” and “2”. To find all the adjacent nodes of it and make the vertex “6” with green. We can see that vertex “8” has weight 7 from vertex “7” while from vertex “6” to vertex “8” it weighs “6”. Since we need minimum weight, we break the edge 8 – 7 and connect 6 – 8

We repeat all the steps as mentioned above, finally, we would able to receive output as where all the nodes are in green color

Now I hope you all got a clear understanding of Kruskal’s and prim's algorithm. You are given the freedom to use any two algorithms to find a minimum spanning tree. Some of us feel Kruskal’s algorithm is easier compared to prim's whereas some others feel the prism algorithm is better than Kruskal’s algorithm.
Therefore I have included both the algorithms here so that you are able to get a good understanding of finding a minimum spanning tree.

See you in our next blog!

Breadth First search and Depth First Search

Mohammed Ashfaq Ashar — Wed, 23 Dec 2020 04:43:16 +0000

Today, we are discussing an interesting concept related to Data Structures and Algorithms that most of the computer science students face many difficulties in, which is Breadth First Search and Depth First Search also known as BFS and DFS respectively.

This tutorial for all the beginners who are facing difficulties related to the graph traversal algorithms. There are several graph traversal algorithms in Data structures and Algorithms, but in our discussion we will be discussing BFS and DFS. Additionally, I would like to give some important background information, so that you would have better foundation in this tutorial in order to further proceed with BFS and DFS.

Why do we need to have graph traversal algorithms?

Before we going further with what is BFS and DFS, it is must to have a clear understanding on why we need this traversal. Normally traversal is used to solve several problems inorder to increase the efficiency. Some examples are:

Finding all the nodes which are reachable
Finding the best reachable node
Finding the best path through a graph And so on. The main goal of this type of graph traversal is to find all the nodes that are reachable from a given set of root nodes.

What is BFS and DFS?

Breadth First Search (BFS) traversal is mainly used to find the shortest path from a given graph. In order to perform the BFS, we need to implement the Queue Data Structure, which follows the principle of FIFO (First In First Out). I hope you all have clear idea of Queue Data structure.

Depth First Search (DFS) traversal mainly traverse the graph in a depthward motion. This traversal is used for cycle detection, strongly connected components and so on. We can implement DFS by using the Stack Data structure, which follows LIFO (Last In First Out) Principle.

Don’t worry, if you can’t understand the Stack and Queue Data Structure the examples in this article will give you a clear understanding on these data structures. Additionally, you will get a good knowledge in finding the BFS and DFS for a given graph.

Finding the BFS for the given graph

Now we have started a more interesting concept that is how to find the BFS for a given graph.

Let's consider the simple graph given above. This problem is solved by breaking our problem into several steps.

Step 1

Initialize a queue. We insert the element in the rear end of the queue and remove the element from the front end

Step 2

Select a starting node and colour it. For our easiness I have selected the element “S”

Step 3

Now, we select the adjacent node of “S”, which is not coloured. According to our example, we can see A, B and C are adjacent of S and not coloured. So, I select “A”. And insert into queue and colour it

Step 4

Now the next element which is adjacent to “S” is “B”. So colour and insert it

Step 5

Similarly, we can observe the next adjacent element of “S” is “C”. Colour and insert it

Step 6

Now we can see there is no further visited nodes of “S”. So, we can remove element. You know that Queue follows FIFO. So, the element to remove is “A”

Step 7

Now we can see only a single adjacent node of “A” which is not visited. So colour it and insert it So finally, we can see there are no further nodes to colour. So, remove all the elements one by one

So, the BFS of the graph is

S, A, B, C, D

I hope you have gotten a better idea in finding the BFS, and also, I hope that now you can solve any type of BFS problem.

Now let us look at how to find the DFS for the given graph

Finding the DFS for the given graph

Similarly, as I explained how to find the BFS, I will help to find the DFS in most simple manner by using the same graph.

But as I explained before, to implement DFS, we need the Stack data structure. As you all aware that the Stack follows LIFO which is Last In First Out Principle.

Step 1

First of all, let's create a stack

Step 2

You can select whatever node as the starting node. As the previous example in BFS, I have taken “S” as the Starting node. Here too I am taking “S” as my starting node. Colour it and put it into stack

Step 3

Now we can see there are 3 adjacent uncoloured nodes, As for our easiness I select “A” next node, colour it and put it into stack

Step 4

Now we can see top element is “A”. So now we have to select adjacent element of “A”. Since “D” is the only adjacent element, we colour it and put into stack

Step 5

Now adjacent element of “D” is “B”. So, we colour and put into stack

Step 6

As a next step, we couldn’t see any adjacent element of “B”. so, we simply remove it, so now top value is “D”.

Step 7

So as a final step, we can observe the adjacent element of “D” is “C”, which is not coloured yet. So, we colour it and put into stack. Now “C” doesn’t have any uncoloured nodes. So, we repeatedly remove the nodes from stack, until we find any uncoloured nodes.

So as a result, The DFS of the above graph is
S, A, D, B, C

From above explanation, I hope that you have gained a clear understanding on BFS and DFS. I kindly request you all to go through this tutorial very carefully along with the images.

Hope to see you soon with my next article!

AI Vs Deep Learning Vs Machine Learning

Mohammed Ashfaq Ashar — Wed, 18 Nov 2020 13:43:32 +0000

Today I came up with an interesting topic which you all are familiar with. That is none other than “Artificial Intelligence, Machine learning and Deep Learning".

I know that most of us have a great confusion will all these terms. Almost 60% of us assumed that all 3 terms are same in all the aspects. But thats completely wrong.
So, first of all, before we go further, let me resolve this confusion. AI which is known as Artificial Intelligence is considered to be an umbrella of Machine Learning. At same time Machine Learning acts as an umbrella for Deep Learning. The following image represents the complete difference of all these terms.

We all think that Artificial Intelligence was introduced recently. But, its also a wrong assumption. Why?

Yes, AI is not a new word to our world as AI was actually introduced in 1956. Even though it was coined during that era, it was not popular as it is today. The reason for that is the shortage of data. With few data, it is impossible to get accurate results. In this modern era, there is a tremendous usage of data. From Data Statistics, it represents that at year 2018, data usage was nearly 4.4 Zettabytes, but at year 2020, it climbs upto 44 zettabytes. Along with enormous data, now we deal with advanced algorithm and high-end computing power & storage that can handle with these enormous amounts of data as a result it is expected nearly 80% of enterprise will implement AI within next 12 months.

So, it is much better for us to have a good knowledge on Artificial Intelligence, Deep learning and Machine learning.

First up, Artificial Intelligence (AI)! What's going on here?

AI is just any code, strategy or calculation that empowers machines to mirror, create and show human perception or conduct. We are in, what many allude to as, the period of "powerless AI". The innovation is still in its earliest stages and is required to make machines fit for busy and all that people do, in the time of "solid AI". To change from powerless AI to solid AI, machines need to become familiar with the methods of people. The procedures and cycles, which help machines in this undertaking are extensively ordered under AI. Machines learn in dominatingly two different ways. Their learning is either directed or unaided.

In managed learning, machines figure out how to anticipate results with the assistance from information researchers. In unaided learning, machines figure out how to foresee results in a hurry by perceiving designs in input information. At the point when machines can draw important deductions from huge volumes of informational indexes, they show the capacity to adapt profoundly. Profound learning requires counterfeit neural organizations (ANNs), which resemble the natural neural organizations in people. These organizations contain hubs in various layers that are associated and speak with one another to figure out voluminous info information. Profound learning is a subset of AI, which thus, is a subset of man-made brainpower. The three innovations help researchers and examiners decipher huge loads of information and are henceforth pivotal for the field of data science.
I hope from the above information you all got a clear understanding about these 3 different terms!