teleren/devto huggingface dataset:
A importância da atividade de teste de software, como forma de melhorar a qualidade
Published: 2022-01-28 14:54:29

Ao produzir um software de qualidade não se pode levar em consideração apenas os objetivos e necessidades dos usuários, também é necessário obter um ciclo de vida de produção de software que apresente as características desejáveis em qualquer processo de desenvolvimento, como boa manutenibilidade, alta reusabilidade e baixo acoplamento. Segundo Mecenas e Oliveira [4], de maneira geral, as empresas, têm despertado para a importância da atividade de teste de software, como forma de melhorar a qualidade dos seus produtos e manterem-se competitivas no mercado. Conduto, a complexidade das tecnologias utilizadas e dos produtos de software produzidos tem crescido, tornando-se indispensável a utilização de processos, técnicas, ferramentas e métodos, que permitam a realização de teste de software de maneira sistemática e com fundamentação teórica, com o propósito de aumentar a qualidade do software, com o menor custo possível desta forma, o processo de teste  exerce um importante papel dentro da garantia de qualidade de software, assegurando que os requisitos satisfaçam as necessidades das partes envolvidas. Neste sentido, a atividade de teste tem como objetivo encontrar defeitos, reduzir os riscos associados a um sistema e identificar o máximo de problemas, efetivando a qualidade dos produtos desenvolvidos.
Buscando uma maior qualidade podemos optar pelo planejamento e condução de experimentos de forma mais sistêmica e rigorosa tornando-os reproduzíveis e auditáveis. Devendo também estes experimentos serem constantemente avaliados  pela sua qualidade  aumentando assim a confiabilidade dos resultados obtidos e evidências fornecidas.
Há um consenso crescente de que a experimentação em Engenharia de Software (ES) é fundamental para desenvolver, melhorar e realizar manutenção de software, métodos e ferramentas (Lopes e Travassos, 2009). Tal consenso permite que o conhecimento seja gerado de forma sistemática, disciplinada, quantificável e controlada (Wohlin et al., 2012).
A comunidade de ES tem discutido como avaliar a qualidade de experimentos na área, utilizando abordagens como: critérios simples de qualidade (Dieste et al., 2011; Teixeira, 2014), checklists (Kampenes, 2007; Kitchenham e Charters, 2007; Kitchenham et al., 2010), escalas de qualidade (Dieste et al., 2011; Teixeira, 2014) e validade de inferência e a documentação dos experimentos (Kampenes, 2007). 
Conclui-se então que a Qualidade de Software tem o intuito de gerir os riscos do produto nas fases de desenvolvimento, apoiando na priorização de testes a serem conduzidos e na estratégia do teste a ser realizada, para assim reduzir a probabilidade e impacto de falhas no produto, permitindo uma entrega de qualidade do produto de software.
What is the difference between ' var ' and ' let ' ?
Tags: javascript, webdev, tutorial, beginners
Published: 2022-01-28 14:50:34



## Scoping : 
The main difference is **scoping rules**. Variables declared by **var** keyword are scoped to the immediate **function body** (hence the function scope) while **let** variables are scoped to the immediate **enclosing block** denoted by **{ }** (hence the block scope).

```
function variablesTest() {
  var dav = "Dav";
  let ron = "Ron";

  console.log(dav, ron); // Dav Ron

  {
    var ilm = "Ilm"
    let hub = "Hub";
    console.log(ilm, hub); // Ilm Hub
  }

  console.log(ilm); // Ilm
  console.log(hub); // ReferenceError
}

variablesTest();
```

The reason why **let** keyword was introduced to the language was function scope is confusing and was one of the main sources of bugs in JavaScript.

## Hoisting : 
While variables declared with **var** keyword are **hoisted** (initialized with undefined before the code is run) which means they are accessible in their **enclosing scope** even before they are declared : 

```
function varCheck() {
  console.log(name); // undefined
  var name = "Davron";
  console.log(name); // Davron
}

varCheck();
```

 **let** variables are not initialized until their **definition** is evaluated. Accessing them before the initialization results in a **ReferenceError**. The variable is said to be in **"temporal dead zone"**(which is probably gonna be the topic for my next article) from the start of the block until the initialization is processed : 

```
function letCheck() {
  console.log(name); // ReferenceError
  let name = "Davron";
  console.log(name); // Davron
}

letCheck();
```

## Global Object Property : 
At the top level, **let**, unlike **var**, does not create a property on the **global object** : 

```
  var x = 'global'; // globally scoped
  let y = 'global'; // not allowed to be globally scoped
  console.log(this.x); // "global"
  console.log(this.y); // undefined
```

## Redeclaration : 
In **strict mode**, **var** will allow you re-declare the same variable in the same scope while **let** raises a SyntaxError.

```
var name = "Davron"
var name = "John"
console.log(name) // 'Davron' is now replaced with 'John'

let surName = "Abdukhakimov"
let surName = "Doe" // SyntaxError Identifier 'surName' has already been declared
console.log(surName)
```
Add New Dependencies to Your Kedro Project
Tags: kedro, python
Published: 2022-01-28 14:49:21

---
canonical_url: https://waylonwalker.com/til/kedro-new-dependencies/
published: true
tags:
- kedro
- python
series: til
title: Add New Dependencies to Your Kedro Project
---

As you work on your kedro projects you are bound to need to add more dependencies to the project eventually.  Kedro uses a fantastic command `pip-compile` under the hood to ensure that everyone is on the same version of packages at all times, and able to easily upgrade them.  It might be a bit different workflow than what you have seen, let's take a look at it.

## git status

Before you start mucking around with any changes to dependencies make sure that your git status is clean.  I'd even recommend starting a new branch for this, and if you are working on a team potentially submit this as its own PR for clarity.

``` bash
git status git checkout main git checkout -b add-rich-dependency
```

## requirements.in

New requirements get added to a requirements.in file.  If you need to specify an exact version, or a minimum version you can do that, but if all versions generally work you can leave it open.

``` bash
# requirements.in
rich
```

Here I added the popular `rich` package to my `requirements.in` file.  Since I am ok with the latest version I am not going to pin anything, I am going to let the pip resolver pick the latest version that does not conflict with any of my dependencies for me.

## build-reqs

The command `kedro build-reqs` will tell kedro to recompile the
`requirements.txt` file that has all of our dependencies pinned down to exact
versions.  This ensures that all of our teammates and production workflows use the same exact versions of packages even if new ones are released after we installed on our development machines.

``` bash
kedro build-reqs
```

## git add

Now that we have our new dependencies ready to go commit those to git, and submit a PR for them if you are working on a team.  This is a good way to document the discussion of adding new dependencies to your teams project.

``` bash
git add requirements.in git add requirements.txt git status git commit -m "FEAT updated dependencies with rich" git push
# go make a pr
gh pr create --title "feat add rich to dependencies" --body "I added rich as a dependency, and ran pip-compile"
```
My opinion about Node.js
Tags: node, opinion
Published: 2022-01-28 14:29:35

---
title: My opinion about Node.js
published: true
description: 
tags: nodejs,opinion
//cover_image: https://direct_url_to_image.jpg
---


I agree that using JavaScript increases the chance of participation. I released a few versions of Thai word breakers in different programming languages. One on node.js is the most popular. 8 people contributed to the JS-based project compared to 2-3 people in other programming languages. However, JS has a downside too. In 2017, @iporsut and I made an experiment to compare Thai word breakers that we created. JS version running time is 15X of the Rust version. Even by comparing with another dynamic language, the Julia version is faster than the one in JS.

I created a website using node.js in 2014, and it is still running. The performance is good. However, I have a few regrets.  
* We had a very hard time by install this project on other team members who use Windows 10 because we didn't know how to build a Bcrypt library. 
* Recently, I have to fix the project without adding any new feature because Express.js was changed, MongoDB was changed, and some packages that I used were abandoned. 
* It was a small project so I wanted to keep the session storage in RAM, but I can't since I ran 4 node.js processes. Now the project requires Redis as session storage, which causes more troubles for team members, who don't familiar with GNU/Linux, Docker, or WSL.
Javascript filter() function
Tags: javascript, 100daysofjs
Published: 2022-01-28 14:25:44

---
title: Javascript filter() function
published: true
description: Memfilter data pada setiap elemen array dengan kondisi tertentu
tags: ["javascript","100daysofjs"]
//cover_image: https://direct_url_to_image.jpg
---
`filter()` dapat digunakan untuk menguji pada setiap elemen array apabila memenuhi kondisi tertentu, jika kondisi tersebut tidak terpenuhi maka elemen pada array tersebut akan dikeluarkan. Sehingga hasil `return` akan menghasilkan semua elemen yang berhasil lolos dari kriteria pengujian.

Misalnya saya akan memeriksa jika masing-masing elemen memiliki nilai yang genap, jika tidak maka elemen tersebut akan dikecualikan.

```js
const numbers = [1, 2, 3, 4, 5];
const evenNumbers = numbers.filter((number) => number % 2 === 0);
console.log(evenNumbers);
```
Output:
`[ 2, 4 ]`


Apabila kita menggunakan lodash _.filter()
```js
const _ = require("lodash");

const numbers = [1, 2, 3, 4, 5];
const evenNumbers = _.filter(numbers, (n) => n % 2 === 0);
console.log(evenNumbers);
```
Output
`[ 2, 4 ]`



Referensi:
[MDN - filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
[Lodash - filter](https://lodash.com/docs/4.17.15#filter)
Best practices for writing clean code
Published: 2022-01-28 14:25:13

Software engineering is not just all about getting to know a language and building some software program. As a software engineer or software program developer, you're anticipated to put in writing the correct software. So the query is what makes good software? The desirable software program may be judged through studying some piece of code written inside. If the code is simple to understand and smooth to trade then absolutely it’s a good software program and developer love to work on that. It doesn’t depend if you are a beginner or a skilled programmer, you need to constantly try and emerge as a good programmer
_**Before moving into the discussion of how to write clean code let's see its characteristics first.**_

1.  Written code should be readable. If someone reads your code they should have an understanding of the code.
2. Code should be pleasing to read and make a smile on your face. 
3. Code should be easy to understand and easy to change.

Now, we come to our main discussion.
## How to write clean code?
**Naming Conventions**
The naming convention is a great way to get started. It keeps code clear and lets you know what you’re working with.

**Comments**
Comments help others to understand your code behavior. Comments in your code are good maybe it means that your code is not self-explanatory.  
Here is a famous quote about writing comments by Jeff Atwood.
“While comments are neither inherently good nor bad, they are frequently used as a crutch. You should always write your code as if comments didn’t exist. This forces you to write your code in the simplest, plainest, most self-documenting way you can humanly come up with.” — Jeff Atwood

We do not say that comments are bad but if you write code well with proper naming convention then your code does not need any comments.

**Avoid redundant code**
Many programmers face this problem they can write too much code and they follow all best practices but somehow their code is repeated. So, make sure that your code is efficient and not repeated again and again.
Lets talk about repetitive code example
Console.log(9 * 1);
Console.log (9 * 2);
Console.log (9 * 3);
Console.log (9 * 4);
Console.log (9 * 5);
Console.log (9 * 6);
Console.log (9 * 7);
Console.log (9 * 8);
Console.log (9 * 9);
Console.log (9 * 10);
}  
This code will work but it's not efficient because the same piece of code is repeated.
Good practice:
We can rewrite that code using a for loop in JavaScript like so:
for (var i = 1; i < 11; i++) {
  console.log(9 * i);
}

**Avoid Large Functions**
When a function is much larger, then it is better to separate it into multiples. This will make code easier, clean, easy to understand, and also reusable.
Suppose we need to add and subtract two numbers. We can do it with a single function. But the good practice is to divide them into two. When there are individual functions, then this will be reusable in the whole application.

**Conclusion**
All these tips help you when you write some code and any programmer will understand your logic and flow of the code.
Angular 13 + NestJs + NX
Published: 2022-01-28 14:24:59

This is an Angular 13 Starter project with Ngx-admin, NestJs, Nx Workspace, Jest, Cypress, ESLint & Prettier

**GitHub: https://github.com/wlucha/angular-nest-nx**

## Features

✅ [Angular 13](https://angular.io/)
✅ [Ngx-admin](https://akveo.github.io/ngx-admin/) 
✅ [NestJS 8](https://nestjs.com/)
✅ Next generation build system with [Nx](https://nx.dev/) 
✅ Unit Testing with [Jest](https://jestjs.io/)
✅ End-to-End Testing with [Cypress](https://www.cypress.io/ 
✅ [ESLint](https://eslint.org/)
✅ [Prettier](https://prettier.io/)

## Frontend App
The Angular 13 frontend app is based on the [ngx-admin](https://github.com/akveo/ngx-admin) starter kit.  

![image](https://user-images.githubusercontent.com/7531596/148551080-de61fdb5-ffa4-496e-a26b-4bbf9dd35e9e.png)

## Install / Development

```bash
# Clone the project
$ git clone https://github.com/wlucha/angular-nest-nx
$ cd angular-starter

# Install dependencies
$ npm install

# Start frontend server
$ npm run start

# Start backend server
$ npm run api

# Open in browser: http://localhost:4200
```

## Commands

- `npm run start` - Start the ngx-admin frontend app
- `npm run api` - Start the NestJS backend
- `npm run lint` - Lint the project
- `npm run test` - Run tests

## License

MIT License

Copyright (c) 2022 Wilfried Lucha

**GitHub: https://github.com/wlucha/angular-nest-nx**
Html tables
Tags: html, table, beginners, css
Published: 2022-01-28 14:23:16

A table is a data structure used to organize information. **Html tables** are used to help web developers organize data in rows and columns. Each row represents a unique record, and each column represents a field in the record.

The first thing we need to be clear about, is that creating tables consists of three main sections, which are: header, body, footer. To create the table we will use different tags, where the main one is `<table> </table>`. This tag wraps around the entire table. To create the table border the tag would be `<table border = "1px"> </table>`and it will add a border around each cell of the table.
- The head of the table is created via the `<thead> </thead>` element. The `<tr>` tag is used to create table rows and the `<th>` tag is used to create table headings. If the width of the table headings needs to be specific, all we have to do is type `<th width = "">` and put the width we want between the quotes. An example of code, written to create a table header is as follows:               
```html
<thead>
    <tr>
        <th width="100">Name</th>
        <th width="100">Gender</th>
        <th width="100">Age</th>
    </tr>
</thead>
```
- The body of the table is created through the `<tbody> </tbody>` element, which contains the main information of the table. The `<td>` tag is used to create table data cells. An example of code, written to create a table body is as follows:
```html
<tbody>
    <tr>
        <td>Bill</td>
        <td>Male</td>
        <td>37</td>
    </tr>
    <tr>
        <td>Jessica</td>
        <td>Female</td>
        <td>25</td>
    </tr>
    <tr>
        <td>Richard</td>
        <td>Male</td>
        <td>18</td>
    </tr>
</tbody>
```
- The end of the table closes with `<tfoot> </tfoot>`, which  creates a separete footer for the table.
```html
<tfoot>
    <tr>
        <th colspan="3">List of people</th>
    </tr>
</tfoot>
```

 
The table we created will look like this:
![Html tables](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/89ian7thehwr19l1kw7r.png)
Paracetamol.js💊| #35: Explica este código JavaScript
Tags: javascript, spanish, beginners, webdev
Published: 2022-01-28 14:20:51

## **Explica este código JavaScript**

```js
const settings = {
  username: "lydiahallie",
  level: 19,
  health: 90
};

const data = JSON.stringify(settings, ["level", "health"]);
console.log(data);
```

-     A: `'{"level":19, "health":90}'`
-     B: `'{"username": "lydiahallie"}'`
-     C: `'["level", "health"]'`
-     D: `'{"username": "lydiahallie", "level":19, "health":90}'`

Respuesta en el primer comentario.

---
Paracetamol.js💊| #34: Explica este código JavaScript
Tags: javascript, spanish, beginners, webdev
Published: 2022-01-28 14:20:19

## **Explica este código JavaScript**

```js
const user = { name: "Lydia", age: 21 };
const admin = { admin: true, ...user };

console.log(admin);
```


-     A: `{ admin: true, user: { name: "Lydia", age: 21 } }`
-     B: `{ admin: true, name: "Lydia", age: 21 }`
-     C: `{ admin: true, user: ["Lydia", 21] }`
-     D: `{ admin: true }`

Respuesta en el primer comentario.

---
The Complete Guide to Business Text Messaging
Tags: marketing, sms, text
Published: 2022-01-28 14:12:21

Business [Text messaging](https://www.gunisms.com.au/sms-text-messaging) is the use of texting to communicate with customers to maintain relations and keep them engaged in your company’s products. Text messaging is one of the most common and sought-after modes of contact due to its high accessibility, opening rates, and efficiency.
Console.log() is not JavaScript
Tags: javascript, webdev, beginners, html
Published: 2022-01-28 13:51:19

### This might be a heartbreak to a lot of JavaScript developers out there, but the truth is...
The very first line of code you ran as a beginner JS developer, viz **`console.log()`, is not a part of the JavaScript language.** Confused? Let me explain.

The console object (whose log method is used to print data on the web console) is one of the **"Web APIs"** provided by the Browser to the JavaScript Engine, which means it is your browser that is providing this functionality that is in return implemented through JavaScript.


All browsers have a _set of built-in Web APIs_ to support complex operations, such as **DOM, Fetch, History, Service Workers, and Web Storage APIs.** Now you may wonder, what exactly is a part of JavaScript then?


Well, the parts of JavaScript that are standard across all environments are detailed in the ECMA Specs (primitives, data types, language grammar and syntax, arithmetic and logical operations, built-in objects and functions, etc.). This means that while `Array.isArray()` is built into JS, `setTimeout()` and console aren’t.

Do you want to learn more about this? check out this [great blog by Nikhil John](shorturl.at/tvBZ3), where he explains this concept in-depth.

Happy coding :)

###10daysofJSfundamentals (Day 1)
Local Storage JS - TRtr
Tags: javascript, cache, nrkdrk
Published: 2022-01-28 13:42:40

Tarayıcı içerisinde kullanıcılara veya uygulamanıza özel veriler saklamak ister misiniz? Hem de süre sınırı bildirmeden? O zaman aşağıdaki bilgiler işinize yarayacaktır.
Kaynak Sahibi : Mert Özen


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gkixev9tubjfzjzox570.png)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6veqi68r64xnf98243oy.png)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hlce7egiasvmb4qniwde.png)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q36h4bf6bs8xawmtxjxi.png)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tmmtrjg0jjv9vvb67u06.png)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tyyw8xjm4u3cva0vtl2v.png)
Tech Recruiters Should Get Rid of These Outdated Ways to Assess Candidates
Tags: blog, software, jobs, recruitment
Published: 2022-03-03 14:25:30

---
title: Tech Recruiters Should Get Rid of These Outdated Ways to Assess Candidates
published: true
date: 2022-01-28 13:41:21 UTC
tags: blog,software,jobs,recruitment
canonical_url: 
---

![_Photo by LinkedIn Sales Solutions on Unsplash_](https://cdn-images-1.medium.com/max/1024/1*y7TwupwaoWMPeYNHYOlQHQ.jpeg)


#### **1. Ignoring Resume**

If the interview starts with asking the candidate’s years of experience in so and so technology then it implies that the recruiter has not reviewed the candidate’s resume. 

That's either an insult to the candidate or shows a broken process at the recruiter's end. If the resume is to be discarded then why care to ask for one in the first place? Fix the attitude or fix the process.

#### **2. Copy questions from the internet**

A technical recruiters job is to evaluate the candidate on one of the two criteria’s,

1. Is she/he equipped with the necessary skills that the job demands?
2. Will she/he scale up to the job demands?

To answer these questions, one needs to ask questions that are relevant to the job description and relevant to the experience of the candidate. Internet is not the place to decide that. Sure one can refer to the questions posted on various blogs but do not blindly copy-paste them from the web.

#### **3. Test Memory Over Understanding**

![memory](https://cdn-images-1.medium.com/max/1024/1*0fUTPc01FIsWnmBPFucc2Q.png)

Testing the candidate’s memory is not going to help either side.

I have interviewed junior developers who understand how certain frameworks work but do not remember certain terms by heart, more so because of the nervousness I believe but even otherwise it's not a sin to not remember method names by heart, we all use IDE’s right?

#### **4. Counting years of experience**

10 years of experience in so and so technology, if not, even a brilliant candidate is rejected.

Why exactly do those years of experience even matter? There have been hilarious instances where the number of years required for a job was more than the years the tech was available in the market.

#### **5. Ignoring Candidates Attitude**

![attitude](https://cdn-images-1.medium.com/max/1024/1*ws1Z7GNEABIj4qYJ_uG4Qg.png)

Skill and experience can be acquired over time but the attitude of a candidate matters a lot. Is she/he eager to learn, do they like to find ways to automate redundant manual tasks, how much time have they invested to upskill themselves, do they experiment with different tech stacks other than the job requirements?

This analysis helps to identify a candidate who is passionate about the work from those who just want to do the bare minimum and go home. Now again, if “bare-minimum-attitude” is what the company is looking for, then spare other candidates who prefer deep work from the pain of working with mediocres.

* * *