teleren/devto huggingface dataset:
How I Cracked My Dream Company BrowsersStack as Software Tester | Software Testing Jobs | Part 1
Tags: webdev, beginners, programming, tutorial
Published: 2023-02-09 06:08:21

Software Testing Jobs : I am going to discuss about the How I Cracked My Dream Company BrowsersStack as Software Tester.  Must watch for Software Testers Freshers.

{% embed https://youtu.be/Pyme7URM9_c %}

✅  Become Automation Tester :   https://thetestingacademy.com

✅ Learn Java : https://sdet.live/educative


Watch Part 2 - https://youtu.be/FVa2CPZtt8Y

Why are we not getting selected for Job?
Reasons behind getting testing jobs, future of automation testing

✅ Download Notes -  https://sdet.live/notes

✅ New Batch - https://go.scrolltest.com/manual


✅ Join Facebook Group :  http://bit.ly/learntesting2019

✅ Website:   https://scrolltest.com

✅ Website:   https://thetestingacademy.com

✅ Twitter: https://twitter.com/itstechmode

🚀 Tools and services I recommend:
Some of the courses that I recommend to become better Automation Tester 🙌🙌

✅API Testing - 
https://www.learnapitesting.com


✅Cypress Tutorial with LIVE Projects -
http://cypresstutorial.com


✅  GET your Free API Testing Guide worth $19 -  https://sdet.live/ttah


#softwaretestingjobs #softwaretestingjobsforfreshers #softwaretestingjobs #softwaretestingjobsforexperienced
The most serious programming error to avoid is failing to do thorough testing.
Published: 2023-02-09 06:27:19

---
title: The most serious programming error to avoid is failing to do thorough testing.
published: true
date: 2023-02-09 05:56:38 UTC
tags: 
canonical_url: https://fullstackflow.hashnode.dev/thorough-testing
---

Programming is a multi-step process that requires a lot of problem-solving. Despite the greatest efforts of programmers, errors are unavoidable. Certain mistakes, however, are more common and have a greater impact on the code's functionality and efficiency. In this blog article, we'll discuss one such blunder that every programmer should avoid.

**"Not sufficiently testing code"** is the one mistake that everyone should avoid.

Code testing is an essential part of the software development process. It aids in the detection of bugs and verifying that the code is functioning properly. On the other side, many programmers either do not test their code at all or do not test it well. This may result in unexpected behavior, bugs, and finally dissatisfied consumers.

To avoid making this mistake, it is critical to establish a rigorous testing approach that tackles all probable scenarios. This includes edge case testing, system compatibility testing, performance testing, and security testing. With the use of automated testing methods, test coverage may be enhanced and the process simplified.

Using the Test-Driven Development (TDD) approach is one of the best techniques to ensure thorough testing. Developers write tests before writing actual code in the TDD approach. This facilitates the specification of exact code requirements and ensures that the code, once built, conforms with those requirements. TDD assists developers in detecting errors early in the development process, making it easier and faster to resolve them.

Finally, fully testing code is a crucial piece in the software development process that should not be overlooked. It can save time and effort while eventually improving the user experience. Avoiding this error will result in a more stable and trustworthy codebase that meets user expectations.
Code-GPT — Make sense of any code, anytime. 🚀
Tags: ai, vscode, webdev, opensource
Published: 2023-02-09 05:46:50


## Introduction 👋

[Code-GPT](https://marketplace.visualstudio.com/items?itemName=vaibhavacharya.code-gpt-va) is an extension for VS Code that provides you **instant explanations for your code** within the code editor using AI.

With Code-GPT, you can:
- 🧠 Get instant explanations for selected code in real-time
- 💡 Increase your coding understanding and efficiency
- ⏳ Save time and minimize frustration with clear code explanations
- 🔍 Improve your coding skills with in-depth code analysis

## Demo 📽

![demo video](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/guhrdx1u22583g7apyjg.gif)

## Installation 📦

1. Open VS Code and click on the Extensions icon in the left sidebar
2. Search for "Code-GPT" in the Extensions Marketplace
3. Click on the Install button for "Code-GPT"

## How to Use Code-GPT 🛠

1. Select the code you want to understand in your VSCode editor
2. Open the Command Palette (press `Ctrl + Shift + P` or `Cmd + Shift + P` on Mac)
3. Type "Explain Selected Code" and select the command from the list
4. Enter your email address if prompted
5. Wait for the response and the explanation will be prepended to the selected code in your VSCode editor

Enjoy the instant and comprehensive code explanations with Code-GPT! 🎉

## Author ✏

- Twitter → [@VaibhavAcharya_](https://twitter.com/VaibhavAcharya_)
- Website → [vaibhavacharya.github.io](https://vaibhavacharya.github.io)
- GitHub → [VaibhavAcharya](https://github.com/VaibhavAcharya)
Private object
Tags: webdev, javascript, beginners, tutorial
Published: 2023-02-09 05:31:15



In the world of web development, it is crucial to ensure the security of sensitive information such as usernames and passwords. To achieve this, there are various methods available to developers, such as hashing, salting, and encryption. In this post, we will focus on a different approach: using symbols in JavaScript to secure the properties of a user object.

### What is a symbol?

A symbol is a unique and immutable data type in JavaScript that can be used as a property key. Unlike strings, symbols are not enumerable and therefore cannot be accessed using a for...in loop or the Object.keys() method. This makes symbols a useful tool for hiding the properties of an object, as they cannot be accessed directly.

[More on Symbols](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol)

Here is an example of how you can use symbols to secure the username and password properties of a user object:

### Example
```
/**
Create a user object that has properties 
username, password and age.
ensure that password and username are secure.
They cannot be called with user.username or user.password
 */
```


### Solution code & explanation

```js
const username = Symbol("username");
const password = Symbol("password");

const firstUser = {
  [username]: "Bianca",
  [password]: "password123",
  age: 21,
};

```

In this code, we create two symbols using the `Symbol()` constructor, `username` and `password`. These symbols are then used as property keys when defining the first user object, which has the properties `username`, `password`, and age. The values of these properties are set to `"Bianca"`, `"password123"`, and `21`, respectively.

If we want to `console.log()` username or password we get `undefined` instead of the value.

```js
console.log(firstUser.username);
console.log(firstUser.password);
console.log(firstUser.age);

/*Result:
undefined
undefined
21

*/
```

### Conclusion

It is important to note that this method of securing properties is not foolproof. The properties can still be accessed if someone has access to the source code and knows the symbols used as property keys. However, it does provide an additional layer of security that can make it more difficult for attackers to access sensitive information.

In conclusion, symbols can be a useful tool for securing the properties of objects in JavaScript. By using symbols as property keys, we can hide properties from direct access and make it more difficult for attackers to access sensitive information.
React Gatsby Help
Tags: react, gatsby
Published: 2023-02-09 05:29:39

I recently download a react-gatsby project.
I couldn't run the project.
-https://github.com/EmaSuriano/gatsby-starter-event-calendar

--------------------------------------------------------------
Error: AssertionError [ERR_ASSERTION]: Please add the value for CLIENT_EMAIL in your environment variables.
--------------------------------------------------------------

I think there are some env values like "PRIVATE_KEY", "PRIVATE_KEY_ID", "PROJECT_ID"...

Please Help Me...
Shell Scripting in Linux
Tags: linux, bash
Published: 2023-02-09 05:23:35

> **Shell** is a UNIX term for interactive user interface with Linux. It understands the commands written by the user. It exists outside of the operating system and it helps in communication between the kernel and the user.


💡 Some examples are cshell, bourneshell, bashshell, tcshell, kornshell.

---

**지역 변수**는 자신을 생성한 Shell에서만 사용할 수 있다

**환경 변수**는 자신을 생성한 Shell 뿐만 아니라, 이로부터 파생되어 나온 자식 프로세스에서도 사용할 수 있다.

```bash
➜  ~ pstree
systemd─┬─ModemManager───2*[{ModemManager}]
        ├─NetworkManager───2*[{NetworkManager}]
        ├─VGAuthService
.
.
.
**├─sshd───sshd───zsh───pstree**
.
.
.
```

<aside>
💡 Just a reminder that `init` starts the processes 'one by one' however, the `systemd` starts processes in a 'group'

</aside>

---

## 변수 선언

```bash
➜  ~ A=itbank
➜  ~ export NAME=waji  
➜  ~ echo A
A
➜  ~ echo NAME
NAME
➜  ~ echo $NAME
waji
```

```bash
➜  ~ env
.
.
.
LESS=-R
LSCOLORS=Gxfxcxdxbxegedabagacad
**NAME=waji**
```

```bash
.bash_profile

# User specific environment and startup programs

PATH=$PATH:$HOME/bin

export PATH
**export NAME=waji**
```

## 제어문

### If-else

```bash
if [ 조건 1 ]; then
		“조건 1이 참일 경우 실행 할 내용”
elif [ 조건 2 ]; then
		“조건 2가 참일 경우 실행 할 내용”
else
		“모든 조건이 거짓일 경우 실행 할 내용”
fi
```

### Case

```bash
case 조건 in
		조건 1 ) 
		“조건 1이 참일 경우 실행 할 실행문”;;
		조건 2 ) 
		“조건 2가 참일 경우 실행 할 실행문”;;
		* ) 
		“조건 1, 조건 2가 참이 아닐 경우 실행 할 실행문”;;
esac
```

### Select

```bash
select 변수 in [ 항목1 항목2 항목3 .. ]
do 
		“항목이 유효 할 경우 실행 할 실행문”
done
```

### For

```bash
for 변수 in 인자1, 인자2, 인자3 … [ 방법.1 ]
for (( 초기값;종료값;증감값 )) [ 방법.2 ] ( ★ )
do 
			“반복하며 실행 할 실행문”
done
```

### While

```bash
while [ 조건 ]
do 
		“조건이 만족하는 동안 반복하며 실행 할 실행문”
done
```

### Function

```bash
function 함수명( ) {
			“함수 내부에서 실행 할 실행문”
}

함수명 # 함수 호출
```

### ETC

```bash
1. [eval]
- 특정 명령어를 변수로 저장하고 원하는 시점에 실행 될 때 사용 된다.
- EX) str=“ls -l /home”
 eval $str

2. [ set, unset ]
- 특정 변수 할당 및 할당 해제시 주로 사용된다.
- 에러 발생 시 ShellScript를 즉시 종료하는 용도로 주로 사용 ( set -e )

3. [ $(명령어) ]
- 특정 명령어를 즉시 실행 할 때 주로 사용된다.
```
Handling Side Effects with useEffect: A Comprehensive Guide
Published: 2023-02-09 05:00:00

**Introduction:**
In the previous articles, we explored the useReducer and useState hooks and learned how they can be used to manage state in React applications. In this article, we will cover another important hook - the useEffect hook - and see how it can be used to handle side effects in our components.

**What is useEffect:**
The useEffect hook allows you to perform side effects in your functional components. It runs after the component has rendered, and can be used to fetch data, update the DOM, or perform any other operations that have an effect on the component or outside of it.

**Example:**
Let's look at a simple example to see how useEffect works. We'll create a component that fetches data from an API and displays it on the screen.

**Code:**
```
import React, { useState, useEffect } from 'react';

const DataFetcher = () => {
  const [data, setData] = useState(null);

  useEffect(() => {
    fetch('https://my-api.com/data')
      .then(res => res.json())
      .then(data => setData(data));
  }, []);

  return (
    <div>
      {data ? (
        <ul>
          {data.map(item => (
            <li key={item.id}>{item.title}</li>
          ))}
        </ul>
      ) : (
        <p>Loading...</p>
      )}
    </div>
  );
};
```

**Explanation:**
In this example, we use the useEffect hook to fetch data from an API and update the state when the data is received. The hook takes a function as its first argument, which is the effect function. The effect function contains the code to perform the side effect.

The second argument to the useEffect hook is an array of dependencies, which tells React when to re-run the effect. In this example, we passed an empty array, which means that the effect will only run once, when the component is first mounted.

In the effect function, we use the fetch API to fetch data from the API and then update the state with the received data using the setData function. When the state is updated, the component is re-rendered with the new data.

**Conclusion:**
The useEffect hook is a powerful tool for handling side effects in your React components. In this article, we looked at a simple example of how to use the useEffect hook to fetch data from an API and display it on the screen. With the useEffect hook, you can handle any type of side effect in your components, from data fetching to updating the DOM.

In this series of articles, we've covered the useRef, useReducer, useState, and useEffect hooks, and learned how they can be used to manage state and side effects in React applications. I hope this has been a helpful guide for you. If you have any questions, feel free to ask in the comments below.
Mastering the Linux Export Command: A Comprehensive Guide for Beginners
Tags: beginners, linux, programming, devops
Published: 2023-02-09 04:19:58

https://www.howtouselinux.com/post/linux-export-command 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qgg5iwz7uq8v8fm73p45.png)
Javascript most asked polyfills
Tags: bind, promise, reduce, filter
Published: 2023-02-09 04:13:51

**ForEach Polyfill:**

```
Array.prototype.forEachPoly = function(cb){
    
    for(let i = 0; i < this.length; i++){
        cb(this[i], i, this);
    }
}
```

**Map Polyfill:**

```
Array.prototype.mapPoly = function(cb){
    let newArr = [];
    for(let i=0; i<this.length; i++){
        newArr.push(cb(this[i], i, this));
    }
    return newArr;
}
```

**Filter Polyfill:**

```
Array.prototype.filterPoly = function(cb){
    let newArr = [];
    for(let i=0; i<this.length; i++){
        if(cb(this[i], i, this)){
            newArr.push(this[i]);
        }
    }
    return newArr;
}
```

**Reduce Polyfill:**

```
Array.prototype.reducePoly = function(cb, optionalInitilizer){
    console.log(optionalInitilizer);
    let acc, i;
    if(optionalInitilizer !== undefined){
        acc = optionalInitilizer;
        i=0
    }else{
        acc = this[0];
        i=1;
    }
    
    for(i; i<this.length; i++){
        acc = cb(acc, this[i],i,this)
    }
    return acc;
}
```


   **OR**

```
Array.prototype.reducePoly2 = function(cb, initializer){
    let acc = initializer;
    for(let i=0; i<this.length; i++){
        acc = acc ? cb(acc, this[i], i, this) : this[0];
    }
    return acc;
}
```

**Call Polyfill:**

```
Function.prototype.callPoly = function(context={}, ...args){
    context.func = this;
    context.func(...args);
}
```

**Apply Polyfill:**

```
Function.prototype.applyPoly = function(context={}, args){
    context.func = this;
    context.func(...args);
}
```

**Bind Polyfill:**

```
Function.prototype.bindPoly = function(context={}, ...args){
    let reqFunc = this;
    return function(...newArgs){
        context.func = reqFunc;
        context.func(...args, ...newArgs);
    }
}
```
Angular 15: Why it's the Future of Frontend Development
Published: 2023-02-09 04:10:46

## Introduction:
As frontend development continues to evolve, developers are constantly searching for the most efficient and effective technologies to build fast and responsive web applications. One such technology is Angular, a popular open-source platform for building frontend applications. With its recent release of Angular 15, this platform is poised to take the frontend development world by storm. In this blog post, we'll explore the advantages of using Angular 15 for frontend development.

1.Improved Performance: Angular 15 comes with several performance improvements, including faster builds, reduced payload sizes, and improved runtime performance. This means that applications built with Angular 15 will be faster and more responsive, providing a better user experience for your customers.

2.Better User Experience: Angular 15 also includes several new features that improve the user experience, such as virtual scrolling and improved drag and drop functionality. These features make it easier to build fast and responsive applications that provide a seamless user experience.

3.Enhanced Development Experience: Angular 15 also comes with a host of development-focused improvements, including improved error handling and debugging, better integration with other tools, and improved testing capabilities. These enhancements make it easier and faster for developers to build and maintain applications, saving time and effort.

4.Scalable Architecture: Angular 15 is built on a scalable architecture that makes it easy to maintain and upgrade applications as they grow. This means that your applications will be able to handle increasing amounts of data and traffic, making them more resilient and scalable in the long run.

5.Large Community: Angular has a large and active community of developers, who constantly contribute to its development and improvement. With over 10 million developers worldwide, the Angular community is a valuable resource for anyone looking to build frontend applications.


## Conclusion: 
In conclusion, Angular 15 is the future of frontend development. With its improved performance, better user experience, enhanced development experience, scalable architecture, and large community of developers, it's no wonder why so many developers are choosing Angular for their frontend development needs. Whether you're a seasoned developer or just starting out, now is the perfect time to dive into Angular 15 and start building amazing frontend applications.
O que é OWASP Top 10?
Tags: veracode, beginners, tutorial, security
Published: 2023-02-09 03:00:00

OWASP Top 10 é uma lista anual de vulnerabilidades de segurança de aplicativos web mais comuns e críticas, elaborada pelo Open Web Application Security Project (OWASP). É uma referência amplamente utilizada e respeitada para ajudar desenvolvedores, profissionais de segurança da informação e empresas a entender e priorizar as principais ameaças à segurança de aplicativos web.

A lista OWASP Top 10 inclui vulnerabilidades como:
- Injeção de código (SQL, comando, etc.)
- Acesso não autorizado e deturpação de dados
- Falta de criptografia de dados sensíveis
- Falta de autenticação e autorização adequadas
- Proteção insuficiente contra ataques Cross-Site Scripting (XSS)
- Proteção insuficiente contra ataques Cross-Site Request Forgery (CSRF)
- Exposição inadequada de informações sensíveis do sistema ou do aplicativo
- Não correção de vulnerabilidades antigas conhecidas
- Uso inadequado de componentes de terceiros, bibliotecas e frameworks
- Falta de segurança na arquitetura e na configuração do sistema

Os desenvolvedores e profissionais de segurança da informação podem usar a OWASP Top 10 como uma referência para identificar as vulnerabilidades mais críticas em seus aplicativos web e para priorizar a correção dessas vulnerabilidades. Além disso, as empresas podem usar a OWASP Top 10 como uma diretriz para incluir verificações de segurança nos processos de desenvolvimento de software e para avaliar a segurança de aplicativos de terceiros antes de implementá-los.

Para saber como a Veracode e a M3Corp podem lhe ajudar em seu programa de segurança, entre em [contato](https://www.m3corp.com.br/contato/).
2306. Naming a Company
Tags: leetcode, algorithms, 100daysofcode, beginners
Published: 2023-02-09 03:53:42

**Problem Statement:**

You are given an array of strings ideas that represents a list of names to be used in the process of naming a company. The process of naming a company is as follows:

Choose 2 distinct names from ideas, call them ideaA and ideaB.
Swap the first letters of ideaA and ideaB with each other.
If both of the new names are not found in the original ideas, then the name ideaA ideaB (the concatenation of ideaA and ideaB, separated by a space) is a valid company name.
Otherwise, it is not a valid name.
Return the number of distinct valid names for the company.

 

**Example 1:**

**Input:** ideas = ["coffee","donuts","time","toffee"]
**Output:** 6
**Explanation:** The following selections are valid:
- ("coffee", "donuts"): The company name created is "doffee conuts".
- ("donuts", "coffee"): The company name created is "conuts doffee".
- ("donuts", "time"): The company name created is "tonuts dime".
- ("donuts", "toffee"): The company name created is "tonuts doffee".
- ("time", "donuts"): The company name created is "dime tonuts".
- ("toffee", "donuts"): The company name created is "doffee tonuts".
Therefore, there are a total of 6 distinct company names.

The following are some examples of invalid selections:
- ("coffee", "time"): The name "toffee" formed after swapping already exists in the original array.
- ("time", "toffee"): Both names are still the same after swapping and exist in the original array.
- ("coffee", "toffee"): Both names formed after swapping already exist in the original array.

**Example 2:**

**Input:** ideas = ["lack","back"]
**Output:** 0
**Explanation:** There are no valid selections. Therefore, 0 is returned.
 

**Constraints:**

- 2 <= ideas.length <= 5 * 104
- 1 <= ideas[i].length <= 10
- ideas[i] consists of lowercase English letters.
- All the strings in ideas are unique.

**Solution:**

**Code:**
```
class Solution {
    

    public long distinctNames(String[] ideas) {
        long ans = 0;
        Map<Character, Set<String>> map = new HashMap<>();
        for (String idea : ideas) {
            char startChar = idea.charAt(0);
            Set<String> values = map.getOrDefault(startChar, new HashSet<>());
            values.add(idea.substring(1));
            map.put(startChar, values);
        }
        for (int i = 0; i <= 26; i++) {
            for (int j = i + 1; j <= 26; j++) {
                long unique = count(map, (char) (i + 'a'), (char) (j + 'a'));
                ans += unique;
            }
        }
        return ans;
  
        
    }
     private long count(Map<Character, Set<String>> map, char a, char b) {
        if (!map.containsKey(a) || !map.containsKey(b)) {
            return 0;
        }
        long common = 0;
        Set<String> first = map.get(a);
        Set<String> second = map.get(b);
        for (String c : first) {
            if (second.contains(c)) {
                common++;
            }
        }
        long uniqueA = first.size() - common;
        long uniqueB = second.size() - common;
        return uniqueA * uniqueB * 2L;
    }
}
```