DEV Community: vicky-ops

HAR Files: A Tester's Tool for Web Performance Insights

vicky-ops — Thu, 14 Sep 2023 18:10:45 +0000

Testers play a vital role in ensuring a seamless user experience. One essential tool in our kit is the HAR file, or HTTP Archive file. It's a log format that reveals intricate details about how a web page loads and the interactions between a browser and server. Here's why HAR files matter:

Performance Insights
HAR files break down the loading process, showing timings for DNS resolution, connection, SSL/TLS handshakes, requests, waiting for responses, and content downloading. This helps identify bottlenecks.

Network Troubleshooting
When a web page doesn't load or behaves unexpectedly, HAR files provide a history of requests and error codes, aiding troubleshooting.

Cookie Understanding
HAR files contain cookie data, helping testers understand cookie usage and potential conflicts.

Cache Analysis
They also reveal cache hits and misses, allowing testers to optimize resource caching.

Generating a HAR file is simple:

Set up your environment with Selenium, a web driver, and selenium-har-util.

Navigate to the web page of interest.

Capture the HAR file by starting and stopping a network listener.

Analyze the HAR file using tools or online viewers.

HAR files empower testers to optimize load times and ensure a smooth user experience.

Happy testing! 🚀

Understanding the Bug Life Cycle in Software Testing

vicky-ops — Wed, 13 Sep 2023 15:35:44 +0000

Before going into Bug life cycle, lets understand what a bug is and why does it even matter.

What is a Bug?

In simple terms, a bug is an anomaly or unexpected behavior in a software application. It's a flaw that can manifest in various ways, from a minor annoyance to a critical issue that renders the software unusable.

Why Do Bugs Matter?

Bugs matter because they can have a significant impact on the quality and reliability of a software product. They can cause crashes, data loss, security vulnerabilities, and user frustration. In today's competitive software landscape, where user experience is paramount, the presence of bugs can lead to loss of customers and damage to a company's reputation.

Understanding the Bug Life Cycle:

To effectively manage bugs and ensure they are resolved in a systematic manner, the software industry has established a Bug Life Cycle. This life cycle consists of several stages, each with a specific purpose and set of actions. Let's take a closer look at these stages:

Discovery: Bugs are first discovered during various phases of software development and testing. This could be during unit testing, integration testing, or even after the software has been deployed.

Logging: Once a bug is discovered, it needs to be logged or documented. This step involves creating a detailed report that includes information about the bug's symptoms, environment, and steps to reproduce it.

Prioritization: Not all bugs are created equal. Some are critical and need immediate attention, while others may have lower priority. Prioritization helps in allocating resources efficiently.

Assigned: Bugs are then assigned to the appropriate team members responsible for fixing them. This step ensures that the right people are aware of and working on the issue.

Open: Bugs can have various statuses at this stage, such as:

Duplicate: If a bug report duplicates an existing one.
Rejected: If the reported issue is not a valid bug.
Deferred: If the bug is acknowledged but scheduled for a later release.
Not a bug: If the reported behavior is expected and not a bug.
Fixed: Once a developer has addressed the bug, they mark it as "fixed" in the system.

Retest: Testers then retest the software to verify that the bug has indeed been fixed and that no new issues have been introduced.

Reopened (may be required): If the bug reappears or is not completely fixed, it may be reopened for further investigation.

Verified: After successful retesting, the bug is marked as "verified."

Closed: Finally, when a bug is resolved, verified, and no longer impacting the software, it is marked as "closed."

In Summary:

The Bug Life Cycle is a crucial process in software development and testing, aimed at ensuring that bugs are effectively managed and resolved. It provides a structured approach to bug tracking, from discovery to resolution, ultimately improving the quality and reliability of software products.

In our ever-evolving software landscape, understanding and mastering the Bug Life Cycle is essential for delivering top-notch software that meets user expectations and maintains a positive reputation for your organization. So, next time you encounter a bug, remember that it's just one step in the journey towards delivering high-quality software.

Verification and Validation in Quality Assurance

vicky-ops — Wed, 13 Sep 2023 15:27:22 +0000

Verification and Validation are two essential assurance processes that are used to ensure a product, service, or system meets its requirements and specifications and that it fulfills its intended purpose.

Verification Process includes checking documents, design, code, and program, Verification does not involve code Execution, Verification Uses methodss like reviews, walkthroughs, inspections, and desk-checking.

Validation Process includes testing an validation of the actual product, Validation involved code Execution, Validation uses methods like black box testing, white box testing, functional and non-functional testing.

Verification find the bugs early in the development cycle, Verification process targets software architecture, design, database, etc. It is done by QA team.

Validation finds the bugs that verification can not catch, Validation process targets the actual software product,Validation is done by the involvement of the testing team with QA Team

Verification process comes before validation, whereas valdation process comes after verificatio.

Guide to Root Cause Analsis - Understanding And Techniques

vicky-ops — Wed, 06 Sep 2023 08:21:07 +0000

Root Cause Analysis (RCA) is a systematic process used to identify the underlying or fundamental causes of problems or issues rather than just addressing their symptoms. RCA is a valuable tool in various fields, including engineering, healthcare, quality management, and business, as it helps organizations prevent issues from recurring and make data-driven decisions for improvement. Here's a step-by-step guide to performing RCA:

1. Define the Problem:

Begin by clearly defining the problem or issue you want to investigate. Be specific about what happened, when it occurred, and its impact. A well-defined problem statement is crucial for a successful RCA.

2. Assemble a Team:

Form a cross-functional team with members who have relevant knowledge and expertise related to the problem. Including diverse perspectives can lead to a more comprehensive analysis.

3. Gather Information:

Collect all available data and information related to the problem. This may include incident reports, documents, records, and interviews with individuals involved.

4. Identify Immediate Causes (Symptoms):

List the immediate causes or symptoms of the problem. These are the most apparent factors that contributed to the issue. Ask "Why did this happen?" and record the answers.

5. Ask "Why" Repeatedly (5 Whys or More):

For each immediate cause identified in step 4, ask "Why?" repeatedly to uncover deeper underlying causes. Continue this process iteratively until you reach a point where further questioning does not provide meaningful answers. Typically, five iterations are sufficient, but you may need more or fewer.

6. Use RCA Tools:

Depending on the complexity of the problem, you can use various RCA tools and techniques, such as Fishbone Diagrams (Ishikawa or Cause-and-Effect Diagrams), Fault Tree Analysis (FTA), Failure Mode and Effects Analysis (FMEA), or Pareto Analysis, to visualize and analyze the causes.

7. Analyze Data and Evidence:

Examine the data and evidence collected during the investigation. Look for patterns, trends, and correlations among the identified causes. This helps in determining the most influential or critical causes.

8. Determine the Root Cause:

The root cause is the fundamental factor or factors that, if addressed, would prevent the problem from occurring again. It is the primary reason behind all the immediate and contributing causes identified through the "Why" questioning.

9. Develop Corrective Actions:

Once the root cause is identified, brainstorm and develop corrective actions to address it. These actions should eliminate or mitigate the root cause and prevent the problem's recurrence.

10. Implement and Monitor Solutions:

Put the corrective actions into practice and monitor their effectiveness. Ensure that the changes made are sustainable and do not introduce new problems.

11. Document the Process:

Maintain detailed records of the entire RCA process, including the problem definition, causes identified, root cause determination, corrective actions, and their outcomes. This documentation is crucial for accountability and future reference.

12. Continuous Improvement:

Encourage a culture of continuous improvement by regularly reviewing and updating the RCA process. Use lessons learned from past analyses to enhance future problem-solving efforts.

By following these steps, organizations can systematically analyze and address problems at their core, leading to more effective and sustainable solutions, improved quality, and increased operational efficiency. Root Cause Analysis is an essential tool for continuous improvement and problem-solving across various industries.

Navigating the Software Testing Life Cycle (STLC): Ensuring Quality Throughout Development

vicky-ops — Fri, 25 Aug 2023 16:42:02 +0000

Introduction:
In the dynamic world of software development, the Software Testing Life Cycle (STLC) is a foundational framework that ensures the reliability and quality of software applications. It's a well-structured approach that guides the rigorous testing process from start to finish. In this article, we'll delve into the crucial phases of STLC, discuss the entry and exit criteria, and highlight its critical role in modern software development.

The Phases of STLC:

Requirements Analysis:
- In-Depth Requirement Analysis: At this stage, the testing team conducts an in-depth analysis of the software requirements and specifications. The goal is to gain a comprehensive understanding of the system under development.
- Scope Definition: Defining the testing scope is pivotal. It involves identifying the features that will be tested, ensuring nothing is overlooked.
Test Planning:
- Detailed Test Plan: Test planning involves the creation of a detailed test plan that leaves no stone unturned. It includes outlining the testing approach, objectives, test strategy, and schedules.
- Resource Allocation: Allocating the right resources is crucial for a successful testing phase. This stage also defines test environments, test data requirements, and the types of testing that will be performed.
Test Design:
- Comprehensive Test Cases: Test design is where the rubber meets the road. Test cases and scenarios are meticulously designed based on the requirements and specifications.
- Thorough Coverage: The focus is on covering every aspect, from functionality to performance, usability, security, and beyond.
Test Environment Setup:
- Setting Up the Perfect Environment: A significant portion of testing success depends on setting up the ideal testing environment. This includes configuring hardware, software, and network settings.
- Tool Selection and Configuration: Test tools and frameworks are carefully selected, installed, and configured to facilitate efficient testing.
Test Execution:
- Putting Tests to the Test: Test execution is where all the planning and design come to fruition. Testers execute the test cases, meticulously recording the results.
- Regression Testing: This phase includes crucial activities like regression testing, retesting, and smoke testing to ensure that recent changes haven't adversely affected existing functionality.
Defect Reporting and Tracking:
- Defects in the Spotlight: When defects are discovered during test execution, they are reported in a dedicated defect tracking system.
- Collaboration: Testers and developers work together to resolve these defects, with clear communication regarding severity, priority, and steps to reproduce.
Test Closure:
- Assessment and Reporting: Test closure activities involve a comprehensive assessment of test results. It culminates in the creation of detailed test closure reports.
- Process Improvement: These reports serve as valuable tools for process improvement and future testing endeavors.

Entry and Exit Criteria:

Entry Criteria: Entry criteria specify the conditions that must be met before commencing a particular phase of STLC. For example, before embarking on test case development, requirements, a deep understanding of the application flow, and a finalized test plan must be in place.
Exit Criteria: Exit criteria outline the expectations that must be fulfilled before concluding a phase. To conclude the Test Case development phase, for instance, you should have completed test cases, identified test data, and, if applicable, ready automation scripts.

Additional Considerations:

Traceability: Throughout the STLC, maintaining traceability is key. This means establishing links between test cases and requirements to ensure comprehensive coverage.
Regression Testing: Regression testing is an ongoing process to detect any unintended side effects of recent changes.
Automation: In the modern software landscape, test automation is a powerful ally. It accelerates repetitive testing tasks and enhances efficiency.
Metrics: Metrics play a vital role in quality assessment. Key metrics include test coverage, defect density, and the effectiveness of test cases.
CI/CD: With the advent of DevOps and Agile methodologies, testing is seamlessly integrated into the development process through Continuous Integration/Continuous Deployment (CI/CD) pipelines.
User Acceptance Testing: Don't forget User Acceptance Testing (UAT), which involves testing the software with actual end-users to ensure it meets their needs and expectations.
Defect Management: Effective defect reporting and tracking are vital. This isn't just about finding defects but managing them through to resolution with clear communication between testing and development teams.

Conclusion:

In the complex and ever-evolving world of software development, the Software Testing Life Cycle (STLC) stands as a guardian of quality. It ensures that your software product meets the highest standards, irrespective of whether you follow a traditional Waterfall approach or embrace the agility of Agile and DevOps methodologies. A well-structured STLC is your compass, guiding you towards delivering software with unwavering confidence.

Preparing for a Cypress Interview: Quickly brushing fundamental understanding

vicky-ops — Thu, 24 Aug 2023 17:51:58 +0000

What is Cypress?

Cypress is an open-source JavaScript-based end-to-end testing framework for web applications. Unlike traditional testing tools, Cypress operates directly within the browser. This means it can observe and control your application in real-time, providing a unique set of features and benefits.

Installation

To get started with Cypress, you'll need Node.js installed. Then, simply run the following command to install Cypress as a development dependency:

npm install cypress --save-dev

Writing Your First Test

Cypress tests are written in JavaScript. Let's create a basic test that visits a website and asserts the presence of an element.

describe('My First Test', () => {
   it('Visits the homepage', () => {
     cy.visit('https://example.com')
     cy.contains('Welcome to Example').should('be.visible')
   })
})

In this example, we:

Describe a test suite.
Specify a test case.
In the test case, visit a web page and assert that it contains the text "Welcome to Example."

Key Features

Cypress offers several features that make it a powerful testing tool:

Time-Travel Debugging: You can see every step taken in your test, making debugging a breeze.
Real-Time Reloading: As you make changes to your test code, Cypress instantly refreshes the test runner.
Automatic Waiting: Cypress automatically waits for elements to become available, eliminating flaky tests.
Simple API: Cypress provides an expressive API that simplifies writing tests.

Unit Testing vs. End-to-End Testing

It's essential to distinguish between unit testing and end-to-end testing. Unit tests focus on testing individual components or functions in isolation, while end-to-end tests, performed with Cypress, simulate real user interactions with your application. Both types of testing are vital for ensuring a robust application.

Handling Asynchronous Tasks

Cypress handles asynchronous code gracefully. It automatically waits for commands to complete. However, you can use cy.wait() for explicit waits, and you can chain commands using .then() to handle asynchronous code effectively.

Continuous Integration

Setting up Cypress in your Continuous Integration (CI) pipeline is straightforward. Install Cypress in your CI environment, configure your test script, and ensure that the necessary dependencies are available. Popular CI platforms like Jenkins, Travis CI, CircleCI, and GitHub Actions support Cypress.

Browser Support

As of my last update in September 2021, Cypress primarily supports Chrome-based browsers. However, work on supporting other browsers like Firefox and Edge was in progress. Be sure to check the Cypress documentation or official website for the latest information on browser support.

Custom Commands

Custom commands in Cypress allow you to encapsulate commonly used sequences of actions into reusable functions, improving the maintainability of your test code.

Handling File Uploads

Handling file uploads in Cypress tests is straightforward. Use the cy.fixture() and cy.get() commands to select a file and upload it to an input field on a web page. The Cypress documentation provides comprehensive guidance and examples for this task.

In conclusion, Cypress is a robust and developer-friendly tool for end-to-end testing of web applications. Its unique features, simplicity, and real-time feedback make it an excellent choice for ensuring your web app functions flawlessly.

Remember, the web development landscape evolves rapidly, and Cypress is no exception. Be sure to consult the official Cypress documentation and community resources for the latest updates and best practices.

Happy testing!

Understanding Regression Testing vs. Retesting

vicky-ops — Mon, 21 Aug 2023 17:45:45 +0000

Introduction

As a software tester, you're well aware that maintaining software quality is paramount. Two cornerstones of software testing, Regression Testing and Retesting, hold key roles in this endeavor. In this post, we'll explore these concepts, drawing distinctions through practical examples.

Regression Testing

Regression testing entails a comprehensive examination to confirm that recent code changes don't disrupt existing software functionalities. It's akin to ensuring that the latest touch-ups to a timeless painting don't alter its essence.

Example:

Imagine you're part of a team working on a sprawling e-commerce platform. The development crew has just made substantial changes to the payment processing module, primarily aimed at boosting security. Now, their concern is whether these changes have inadvertently triggered any glitches or disrupted existing payment methods.

Here's how regression testing unfolds in this context:

Baseline Testing: Initially, the payment methods underwent rigorous testing to establish a baseline.
Code Amendments: With the security enhancements integrated, you receive the updated code.
Regression Test Suite: You've got a set of predefined test cases covering various payment scenarios.
Test Execution: These test cases are applied to the modified payment module. If any test fails or exhibits unexpected behavior, it signals a regression issue - a novel problem arising from the recent changes.
Bugs Unveiled: If discrepancies emerge, you document them, and the development squad rectifies these before the software release.

In essence, regression testing acts as an ongoing safety net, ensuring that recent modifications haven't compromised established functionalities.

Retesting

Retesting, conversely, is a more targeted approach. It involves examining a specific functionality or feature that has undergone adjustments or bug fixes, with the aim of confirming that the reported issue has been successfully addressed. Think of it as double-checking that a stain you tried to remove from a shirt has indeed disappeared.

Example:

Suppose you stumbled upon a critical bug in the 'Add to Cart' feature of the e-commerce platform. Whenever a user added an item to the cart, it mysteriously duplicated. The development team diligently worked to fix this issue, and it's now your task to retest it.

Here's how retesting plays out:

Initial Bug: You initially reported the issue, including precise steps to replicate it.
Development Fix: Developers investigated and resolved the bug.
Retesting Phase: Your role now is to rigorously follow the exact steps you initially provided to reproduce the bug. If the bug no longer rears its head, you can confidently assert that the problem has been successfully rectified.
Closing the Chapter: If the bug vanishes during your retesting, you mark the issue as resolved and close the bug report.

The crux here is that retesting zeroes in on a specific issue, confirming its resolution, while regression testing maintains a broader focus to detect inadvertent side effects.

Conclusion

In sum, regression testing and retesting are pivotal components of software testing, each possessing a distinct purpose. Regression testing acts as a safeguard against unintended consequences of code modifications across the entire application, while retesting verifies the successful resolution of specific issues. As a software tester, mastering these techniques is indispensable in your role to guarantee a robust and glitch-free software product.

Demystifying Test Scenarios and Test Cases in Testing

vicky-ops — Sun, 20 Aug 2023 14:53:46 +0000

As a Software Development Engineer in Test (SDET), I'm often asked about the difference between test scenarios and test cases, particularly when it comes to testing. Let's dive into this essential aspect of software testing and clarify why understanding this distinction is vital for ensuring the quality of platforms.

Test Scenarios: A Bird's Eye View

Test scenarios provide a high-level, big-picture perspective of what we aim to test. They describe the overall context, objective, and scope of the test. In the realm of e-commerce, a test scenario outlines the fundamental functionalities or user interactions we need to assess. It's like setting the stage for our testing efforts.

Example of a Test Scenario (E-commerce Application):
Imagine we're testing an e-commerce platform. Our test scenario could be: "User completes a purchase transaction."

In this scenario, we're focusing on a significant user action—making a purchase. It doesn't delve into the specifics of how to do it; instead, it sets the testing stage.

Test Cases: Nitty-Gritty Details

Now, let's move to the detailed level—test cases. Test cases are the actionable, step-by-step instructions for executing a particular test scenario. They define precisely how we'll navigate through the application, what inputs we'll provide, and what results we expect at each step. In our e-commerce example, test cases break down the scenario into manageable steps.

Example of a Test Case (E-commerce Application):
For our "User completes a purchase transaction" scenario, we'd create individual test cases for each step:

Test Case 1: Log In

Action: Log in to the user account.
Expected Result: Successful login, user's dashboard displayed.

Test Case 2: Product Selection

Action: Search for a specific product, add it to the cart.
Expected Result: Product added to the cart, cart total updated.

Test Case 3: Checkout Process

Action: Go to the cart, proceed to checkout.
Expected Result: Checkout page displayed, shipping and payment options available.

And so on, until we've covered each step in the scenario.

Why This Distinction Matters in

Understanding the difference between test scenarios and test cases is vital, especially when testing applications:

Effective Planning: Test scenarios help us plan our testing efforts by identifying critical user journeys or functionalities, like purchasing a product.
Comprehensive Testing: Test cases ensure that we test each step rigorously. This granularity helps catch issues at every stage, ensuring a smooth user experience.
Reproducibility: Well-defined test cases make our testing repeatable. Anyone following the same steps should achieve the same results, making it easier to identify and fix issues.
Prioritization: With test scenarios, we can prioritize what's most crucial to test based on business objectives. Test cases allow us to thoroughly assess each priority item.

In summary, test scenarios set the stage for testing by outlining high-level objectives, while test cases provide the detailed script for executing those objectives. Both are essential for thorough and organized testing of applications, ensuring the best possible user experience.

SubArray/SubString

vicky-ops — Tue, 31 May 2022 06:00:38 +0000

Sub Array/Sub Strings

A Sub array or a subString is **contiguous part** of array/strings.
subarray's are part of like array's with in array's.
Let's look into some example

Find the substrings of "masai":
 The total number of non-empty substrings are 15 . You might ask how? lets find it mathmetical way

     //Given string
     let str = "masai";
    // finding the length/total element
     let n = str.length
     //Once we have total count of element which is 5 here
     // the formula is easy n*n+1/2
    //  So that's it lets apply the formula here
    // so here n=5 according to the formula
    // 5*5+1/2 = 15
    // so total of non-empty sub-stings will be 15

 Formula is n*n+1/2
 n is the total count of element/length

 Now lets find the substrings of the string on pen and paper

Here is the list of possible substrings of the string
'm' 
'm' 'a' 
'm' 'a' 's' 
'm' 'a' 's' 'a' 
'm' 'a' 's' 'a' 'i' 
'a' 
'a' 's' 
'a' 's' 'a' 
'a' 's' 'a' 'i' 
's' 
's' 'a' 
's' 'a' 'i' 
'a' 
'a' 'i' 
'i'

There we have it exactly 15 sub-strings.

Anyway Here is the javascript implementation to get substings.

let str = "masai";
for(let i = 0;i<str.length;i++){
  let str1 = "";
  for(let j=i;j<str.length;j++){
    str1+=str[j];
    console.log(str1)
  }
}

Primitive type

vicky-ops — Sat, 02 Apr 2022 17:15:41 +0000

javaScript Oh boi!! the defacto language for Web. And for today we will be focusing on it's types mainly its Primitive type .

But before jumping on Primitive type, lets discuss bit about the language itself. Javascript is a dynamic language it basically means variables in javascript are not directly associated with any particular type.

Depending on its type js broadly can be divided upon ::

Primitive types.
Objects.

Primitive Type

Primitive Type is immutable by nature, So what does it means,
a piece of code can summarize it nicely.

let number1 = 1;// we are declaring a variable and assigning with a Number 1
number1 = 2;//Here we are reassigning number1 to 2, in any way we are not updating it.

So, As in the comments in the above code we are not mutating the variable simply we are reassigning it. As for every other Primitive type they are immutable in javascript.

In JS we have 7 primitive types ::

1.Number.
2.Big Int.
3.String.
4.Undefined.
5.null(techically object)
6.Boolean
7.Symbol(recent addition the langauge ES2015)

But, we are going too fast right, some people might ask how do get to know its type . Simply we can use typeof operator to check for it, it will be useful so we will try to remember it.

Numeric Type ::

Javascript has two Numeric types
1.Number type
2.BigInt

Number type in javascript are not integers they are floating-
point numbers, Technically double-precision 64-bit binary
format. So below is Code Summary

const num = 1;//variable assignment to a Number type
typeof(num); //will return type of number
console.log(Number.MAX_SAFE_INTEGER);//will return `9007199254740991` as the max safe integer.
console.log(Number.MIN_SAFE_INTEGER);//will return `-9007199254740991` as the min safe integer.

BIG INT comes handy if you want to work on really big numbers even beyond Number.MAX_SAFE_INTEGER or its inverse Number.MIN_SAFE_INTEGER . Mozilla docs wraps it nicely have a look if you want to dive deeply. we will skip to next type😎.

String Type ::

String is fundamental type regardless of whatever type of language it is. Rule of Immutability play's here as well it means when we are adding a character or concatenating two strings we are reassigning the previous string to a new string, not necessarily modifying the old string.
Its fairly a basic data type for any language. So, look at the code below ::

const name = "Richard"//A simple variable declarations with a string assignment
typeof(name)/will return string

Undefined

Yes undefined is a type and it is used implicitely in javascript even if your not using it explicitly. what does it means below code block it clear it out.

let name //say you forgot to assign value to the value, javascript implicitely assigns undefined as its value.
typeof(name);//so it will return undefined as its value.
//avoid undefined in case of intentional empty variable assignment use null instead.

null type

null is a primitive type in javascript, it is represented by literal null. and mostly null represents intentional absence of any value by developer.
But typeof null returns objects type there are many article are out there for this weird behaviour, its a bug to-be precise according to lot of articles.

let name = null;//intentional absence of any value assignment.
typeof(name); //will return object , weird isn't it.
//both undefined & null seems to be same but they are not
console.log(undefined == null);// will return true they are both absent of any value.
console.log(undefined === null);// will return false here cause we are checking both value and type. Their type is different

above code also makes it clear that undefined and null are not same they have some similarity but of different use. be smart before using each of one them.

Boolean type

Boolean types are represented by two literal true and false, yes as simple as that. And Booleans are everwhere from any conditional like if-else,switch to operator like == & ===. So proper understading is mandatory. Code below will clear it out.

const bool = true // will assign true boolean as value to bool variable.
typeof(boo);//will return boolean
if(bool){return "boole= "+bool}// here if block is going to run only if the value bool evalutes to true try changing to false it will not run

Symbol

Symbol is a primitive type in javascript like other types mentioned above. Its Added in ECMAScript 2015 fairly recent addition. unlike others Number,String,null,undefined,boolean it doesn't have any literal it represent it

To create a new Symbol we use global method method like below ::

let userName = Symbol('name')

As with Symbol with each invokation of Symbol()it returns unique private value so Symbol() == Symbol() will be false.

Symbol() == Symbol();//returns false

So, here we are at the end of this post. I made an effort to simplyfy things in javascript which seems daunting from a new developers perspective. javascript have lot of concepts which are needed to-be well understood to leverage the language itself, I am following this amazing github repository for holistic javascript undersanding, Check it guys/gals.

Queue using Linked List ES6

vicky-ops — Tue, 15 Mar 2022 16:27:00 +0000

Queue

Queue is an Abstact data structure, similar to Stacks, but differs, a queue is open at its both ends, One end is used to insert data (enque) and the other is used to removed data (dequeue). Queue follows First-in-First-Out methodology.

A real-world example is a queue of people waiting for getting vaccinated for covid. First comers will get vaccinated first.

Operations

Fundamental Operation ::
1. enqueue() -- store an item to the queue;
2. dequeue() -- remove an item from the head/first element
Auxilary operation::
1. peek() -- Get the first element with-out dequeue()
2. isfull() -- Checks if the queue is full.
3. isempty() -- Checks if the queue is empty.

Javascript implementation of Queue (Linked-List)

// Queue implementation in linked list

// Node class
class Node {
    constructor(value){
        this.value = value;
        this.next = null;
    }
}

class Queue {
    constructor(){
        this.first = null;
        this.last = null;
        this.length = 0;
    }

    peek(){
        // check if the list if empty
        if(this.length === 0 ) return 'List is empty';
        return this.first
    }
    enqueue(value){
        const newNode = new Node(value);
        // check if the list if empty
        if (this.length === 0){
            this.first = newNode;
            this.last = this.first;
        }else {
            this.last.next = newNode;
            this.last = newNode
        }
        this.length++
        return this
    }

    dequeue(){
     if(!this.first){//if first is equal null
         return 'Empty List'
     }
     if(this.first == this.last){
         this.last = null; //remove the last reference
     }
     const holding = this.first.next;
     this.first  = holding;
     this.length--;
     return this;   
    }

}

// new instance of the Queue
const queue = new Queue()
// peek 
console.log(queue.peek())
// enque first node
console.log(queue.enqueue("Gopi"))
console.log(queue.enqueue("Venkata"))
console.log(queue.enqueue("Poorna"))
// peek again
console.log(queue.peek())
// Dequeue
console.log(queue.dequeue())
console.log(queue.dequeue())
console.log(queue.dequeue())
console.log(queue.dequeue())