teleren/devto huggingface dataset:
How to Overcome Agile Testing Challenges?
Tags: agile, testing, challenges
Published: 2020-03-05 06:32:41

As far back as agile testing challenges were presented in software development, the job of QA in agile testing has changed impressively. There is never again a group of QA sitting in a corner, away from the developers and designers, hanging tight for the development team to hand over a bit of work for testing. 
One of the most significant components for QA in the agile process is having a decent comprehension of the nimble advancement procedures and procedures. Numerous nimble organizations pursue the Scrum system for conveying quality programming, so guarantee you know about Scrum.

<a href="https://www.testingxperts.com/services/devops-agile-testing/">Agile Testing Challenges</a>

The very embodiment of an agile process is conveying working programming as often as possible, each time including or upgrading a little highlight which is of incentive to the client. That itself represents a ton of tests for analyzers as well as designers and any other person engaged with the conveyance of application. 
 
Last-minute changes
Changing necessities or dropping stories mid-dash isn't phenomenal in an agile process. This can be a bad dream for the entire group as it implies that the work previously did may be rejected totally or changes ought to be made to what's as of now half done.
These last-minute changes can affect the whole application and can frustrate testers. 

Not Enough Information on Topic
Sometimes a product owner who composes client stories has some thought regarding another element however doesn't have every one of the details to compose a decent arrangement of acknowledgment criteria to know the behavior of the feature. They ask the developer to make a model so they can get more thoughts regarding the usefulness and behavior of the feature.

Continuous Testing
In agile, testing isn't a stage, it's an activity. Testing begins from the earliest starting point, even before the improvement begins. 

So as to have a smooth ride during the sprint, the accounts in the backlog ought to have been explained during the story preparing sessions. This implies the QA ought to team up with item proprietors to get familiar with the subtleties of the story and after that help compose great acceptance criteria.
Test Automation
Working in an agile situation implies that the testers ought to be in fact able to assist the developers with Integration Testing and API Testing, just as scripting UI automation checks with Selenium or comparative tool.

Multiple browsers and devices
Design of website nowadays having back end and front ends So front end changes only based on java and CSS which can perform differently when tested from different browsers or devices.
Top Widgets of the Week
Tags: flutter, opensource
Published: 2020-03-05 06:18:06

Hey Everyone,

Thank you all for your support and feedback that has been providing us for [GetWidget](https://www.getwidget.dev/).

**Here are top 3 GetWidget widgets of the Week**

**1. GetWidget Button Widget:**
 
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/cyelqlsa3f548l94osl2.png)

Every app has a call to action features and button is the most common widget component to any application have for any submit call to action. So obviously we have been getting more requests on Button. If your Flutter app has a button then and looking to the awesome variant in button widget and how to start then check out our documentation at [GetWidget Button Widget](https://docs.getwidget.dev/gf-button).

**2. GetWidget Avatar Widget:** 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/eh0hbiqibxe9got6i6wd.jpg)

Avatar is a component that has been used to show the user image or icon in specific sizes and shapes. It is basically used to show the user profile image in a circular shape. Generally, Avatar is an Image and that image should have a specific shape. In case of Avatar does not have an image icon then it typically has user initial with text. This is the 2nd most request widget we have because now these days most of the application has signup features that have avatar features to make nice and presentable for users. So if you have signup features then you can start our awesome variant of Avatar Widget at [GetWidget Avatar Widget](https://docs.getwidget.dev/gf-avatar).

**3. GetWidget Alert Widget:** 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/hvwjnpdkvuj13vz00diz.png)

GFAlert is a simple widget that is used to show some information and wait for the user's action. An alert dialog informs the user about situations that require acknowledgment. An alert dialog has an optional title and an optional list of actions. IT has been used in most general app because in most applications we have some extra alert features. If your Flutter apps required alert features then could check out Alert Widget at [GetWidget Alert Widget](https://docs.getwidget.dev/gf-alert).

**4. GetWidget Toggle Widget:**

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ofehelpnk3xz9382kcp7.png)

It is used to toggle the on/off state of a single setting. On/off switches toggle the state of a single settings option. The Switch widget implements this component. So if your Flutter application has state management requirements like on/off feature then you can check out our Toggle widget to start and how to implement this widget check out our guide at [GetWidget Toggle Widget](https://docs.getwidget.dev/gf-toggle).

**If you are new then you can check start from here:**

GetWidget Docs: https://docs.getwidget.dev/

**If you would like to contribute and issues then check out on GitHub repository:**

GetWidget GitHub Repo: https://github.com/ionicfirebaseapp/getwidget
What is your opinion on callbacks in JavaScript?
Tags: discuss, javascript, webdev
Published: 2020-03-05 05:41:15

Is it just the reminiscent of the Dark Ages past? Why are standard Node modules, and sometimes NPM full of these (e.g. `sqlite3`, `nedb`)?

When is it more preferable to Promises? What about not-yet-standard features, like Observable?

Do you use `util.promisify` often? What about `...Sync()` functions (such as `fs.readFileSync()`)?
Refactor code doesn't look like Ruby
Tags: rails, ruby, refactoring
Published: 2020-03-05 05:05:46

## The first code
The code I've reviewed is like this. I got many questions.

```ruby
class CompanyController < ApplicationController
  def my_fields
    data = [] # 🤔 1. why it's initialized?
    my_fields = MyFieldMaster.all
    my_fields.each do |field| # 🤔 2. Unclear the intention of the author
      parent_id = if field[:parent_field_id] == 'DEFAULT'
                    nil
                  else
                    field[:parent_field_id]
                  end
      # 🤔 3. this each block has two of responsibility. The first one is if/else.
      # 🤔 4. The second is to make an array data includes hashes.(This could be the main purpose in this each block.
      data << { 
        id: field[:field_id], name: field[:field_name], parentId: parent_id
      } # 🤔5. And Why field[:field_id]? Isn't it attribute?
    end
    render json: data, status: :ok
  end
end
```

## The first refactoring
- 🤔1. Stop initialize
  - Use `.map` instead of `.each`
- 🤔5. Use method instead of `field[:field_id]`

```ruby
class CompanyController < ApplicationController
  def my_fields
    my_fields = MyFieldMaster.all
    data = my_fields.map do |field|
            parent_id = if field.parent_field_id == 'DEFAULT'
                          nil
                        else
                          field.parent_field_id
                        end
            { id: field.field_id, name: field.field_name, parentId: parent_id }
          end
    render json: data, status: :ok
  end
end
```

## The second refactoring
- 🤔 2. make it clear the intention of the author by extract not the main purpose.
  - 🤔 3. it should be extracted to a method
  - 🤔 4. only this process remains.

```ruby
# 🦄 Extracted code
class MyFieldMaster
  def masked_parent_field_id
    field.parent_field_id == 'DEFAULT' ? nil : field.parent_field_id
  end
end

# 🦄 Original code which is refactored
class CompanyController < ApplicationController
  def my_fields
    data = MyFieldMaster.all.map do |field|
            { id: field.field_id, name: field.field_name, parentId: field.masked_parent_field_id }
          end
    render json: data, status: :ok
  end
end
```
Custom Jest Snapshots Directory Setup
Tags: react, reactnative, testing, javascript
Published: 2020-03-05 04:31:49

When you want to place your component test files right next to the component's but you don't want your directories littered with `__snapshots__/` dirs:


```js
// __snapshots__/snapshotResolver.js

module.exports = {
  resolveSnapshotPath: (testPath, snapshotExtension) =>
    testPath
      .replace(
        /\.test\.([tj]sx?)/, 
        `.test${snapshotExtension}`
      )
      .replace(
        /src([/\\]components)/, 
        '__snapshots__'
      ),

  resolveTestPath: (snapshotFilePath, snapshotExtension) =>
    snapshotFilePath
      .replace(snapshotExtension, '.js')
      .replace('__snapshots__', 'src/components'),

  testPathForConsistencyCheck: 'src/components/some.test.js',
}
```

```js
// jest.config.js

module.exports = {
  preset: 'react-native', // optional depending on your project

  snapshotResolver: './__snapshots__/snapshotResolver.js',

  testMatch: [
    '**/__tests__/**/?(*.)+(spec|test).(js|ts|tsx)', 
    '**/?(*.)+(spec|test).(js|ts|tsx)'
  ],
}

```
Dynamic Styling in Vue.js: Inline CSS
Tags: vue, webdev, css, todayilearned
Published: 2020-03-05 03:22:40

If you know me, you know I like Vue.js fro some reason, I don't hide my love for it's simplicity and elegance. I almost always learn something super cool that you can do with it. You know - developers, always learning. Today in my Vue adventures, I'm sharing a brief into to dynamic styling.

I was putting together a project and thought, "Wouldn't it be cool if we could change background colours dynamically by injecting a JavaScript data object into CSS?" - sort of.. A few google searches later I came found that Vue.js supports this. 

In the official Vue.js Documentation, it's referred to as [Class and Style Bindings](https://vuejs.org/v2/guide/class-and-style.html)

Have a look ✨

{% codesandbox x6pnl %}

> Please don't shame me for my crappy CSS, I really had to put this together quick  😖

Anyways I think it's a pretty cool way to do styling for some very specific use cases.  

- Animating buttons for user actions
- Highlighting fields to emphasize a certain flow
- Customizing user display options

In my example, I used inline CSS to change the styling of tags. You could change the font size, text decoration or colour. In theory as long as it is a CSS property, Vue can change it dynamically. If you look through the CodeSandbox code, you notice a couple of data properties - `textSize`,`textColor` and `textDec` all interpolated into some inline CSS as a reference value for specific CSS properties and that's it. Super fun.

> Note: CSS has uses kebab case (*font-size*) and that throws errors for inline styling. Vue lets you use the camel case equivalent (*fontSize*) to style things dynamically just in case you get into some trouble.

We can keep adding a bunch of inline CSS with the data properties but it's messy and does make the most readable code ever. So lets over complicate things (jokes) and go for CSS classes!  Hopefully they'll be cleaner. 

Just as we did for styling, we can bind classes to HTML in. We'll do that next time with hopefully *much* better CSS and more real world examples. Let me know if you try it and how it works out for you.
Exploiting the generator to make a pause/resumable flow.
Tags: webdev, javascript
Published: 2020-03-05 03:13:55

> *Sorry English is not my primary language, please bear with me :p*

Recently I've come up with an idea that I've never seen anyone has used it before.

That is, to use generators as a linear flow control. 

Such as you have a liner program, but sometimes you need to pause it somewhere and resume it later when some condition is met or waiting for an user input.

You don't want to make that program separate functions since it's messy and can fall into the callback hell easily. Also, that not looks linear at all!

So I came up with this monstrosity:

```javascript
const next = (_=((function*() {
  // ...
})())).next.bind(_);
```

Essentially it's just this, but in one line:

```javascript
const generator = function*() {
  // ...
}
const iterator = generator();
const next = iterator.next.bind(iterator);
```

What does this thing do? Let's have an example.
Such as this interactive dialog. The first time when you run `next()`, it will print the first dialogue, and stops at `yield`.

Then you call the `next()` function again. It starts where it was before, and print out the next dialogue. how cool is that?

```javascript
const sarahStyle = 'color: orangered; margin-right: 1em;'
const yourStyle = 'color: lime; margin-right: 1em;'

const next = (_=((function*() {
  console.log('%cSarah:', sarahStyle, 'Hello, my name is Sarah. What is your name?');
  yield;

  console.log('%cYou:', yourStyle, 'Hi, my name is James. Nice to meet you.');
  yield;

  console.log('%cSarah:', sarahStyle, 'Wanna go out for a walk?');
  console.log('%cSarah:', sarahStyle, 'Since it\'s such a nice weather outside.');
  yield;

  console.log('%cYou:', yourStyle, 'Sure, why not?');
})())).next.bind(_);

next();
next();
next();
```

But you might ask, why not just use `await` like this?
```javascript
console.log('%cSarah:', sarahStyle, 'Hello, my name is Sarah. What is your name?');
await somethingIsDone();
console.log('%cYou:', yourStyle, 'Hi, my name is James. Nice to meet you.');
await somethingIsDone();
console.log('%cSarah:', sarahStyle, 'Wanna go out for a walk?');
console.log('%cSarah:', sarahStyle, 'Since it\'s such a nice weather outside.');
```
That's a very good question.

I think the generator solution has 2 major advantages:

1. the `next()` function returns a state object, which looks like this: `{value: undefined, done: false}`. So you can easily determine whether this flow is done or not. But for async functions, you have to get the instance of the promise first.

2. It resumes itself by just calling the `next()` function again. If you're using a promise instead, you have to find a way to resolve the promise to make the flow continue, which is less straightforward.

Here's an example that I use this technique to create an installation simulator:

{% codepen https://codepen.io/wheatup/pen/rNaJaqX %}

Hope you find this is useful, happy coding :)
Vue 3: Smaller, Faster & Stronger.
Tags: vue, javascript, webdev
Published: 2020-03-05 02:04:17

---
title: Vue 3: Smaller, Faster & Stronger.
published: true
description: In this presentation, I am going to talk to you about some of the new and exciting features coming to Vue 3.
tags: vue, javascript, webdev
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/lrzb78hbxd6wk0ki4mpe.png
---

In this presentation, I am going to talk to you about some of the new and exciting features coming to Vue 3. I originally put this presentation together for a conference called CodeMash. I put a lot of work into this presentation and have only given it twice now so I decided to sit down and record it for a larger audience.

{% youtube HmdKqXP8JR8 %}

This presentation will cover: 
  ✅ Vue.js release history
  ✅ Request for Comments (RFC) process
  ✅ Smaller ( Global API Change, Tree shaking, TypeScript & Fragments)
  ✅ Faster (Virtual DOM, Reactivity Updates) 
  ✅ Stronger (Composition API) 

Question: What are your favorite new features in Vue 3?
What Tool Can You Never Remember or Get Good At?
Tags: discuss, tools, productivity
Published: 2020-03-05 01:16:46

What program, application, or shortcut have you never been able to get behind, even though most people tout up as the best thing for developing? It could be either because you don't care to learn/use it, or because you always forget _how_ to use it.

For me, its `tmux`. I realized it today when I kept complaining about my `ssh` session crashing and having to start again. My teammate reminded me that `tmux` has persistent sessions, but after 3 or 4 times of trying to use it more often, I just find it frustrating and never really use it. Maybe one day I'll actually get good at using it, but for now it just seems like a lot of trouble and time that will slow me down in the short term.

Some other honorable mentions:
* `vim` / `emacs`: I know the basics of `vim`, but holy heck am I slow at making changes
* `curl`: I basically need to relearn `curl` every time I want to make a simple request from the command line
¿Como instalar node.js en Servidores Ubuntu 18.04.?
Tags: node, npm, ubuntu
Published: 2020-03-05 01:03:22

# ¿Como instalar node.js en Servidores Ubuntu 18.04.?

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/giuw3zssjzy077qu8815.png)

Hoy les traigo como instalar **Node.js** y **npm** dentro de nuestros servidores Ubuntu.

Explicamos un poco más sobre esto y mostrare la manera más fácil de realizarlo.

## ¿Que es Node.js?

Concebido como un entorno de ejecución de JavaScript orientado a eventos asíncronos de código abierto, **Node.js** está diseñado para construir aplicaciones en red escalables.

**Node.js** está influenciado por sistemas como **Event Machine** de **Ruby** ó **Twisted** de **Python**. **Node.js** lleva el modelo de eventos un poco más allá, este presenta un bucle de eventos como un entorno en vez de una librería.(1)

## ¿Que es npm?

Es el registro de software más grande del mundo, los desarrolladores del mundo usan este registro para compartir y utilizar paquetes de código abierto.(2)

## Instalacion
Podemos realizar la instalación por medio de [NodeSource](https://nodesource.com/).

**NodeSource** es una compañía enfocada a proporcionar soporte de **Node.js** y cuenta con un repositorio para el uso de las últimas versiones de **Node.js**

Para instalar Node.js y npm desde repositorio NodeSource, vamos a seguir los siguientes pasos:

1. Habilitaremos el repositorio por medio del *curl*, si es necesario tener privilegios recuerda usar *Sudo*
  
    ```
    $ curl -sL https://deb.nodesource.com/setup_10.x | sudo -E bash -
    ```

2. Instalamos Node.js y npm de la siguiente manera:

    ```
    $ sudo apt install nodejs
    ```
      Este paquete contine tanto **node** como los binarios de **npm**.

3. Y una vez terminado de instalar, verificamos que ambos estén instalados completamente:

      ```
      $ node --version
      Output
      v10.19.0

      $ npm --version
      Output
      6.13.4
      ```

voilà, todo listo, esta es la manera más fácil y sin tantos rodeo, hay otras dos maneras de realizarlo ya sea por NVM y/o por repositorios de ubuntu, si quieres un ejemplo de algún otra forma puedes dejarlo en los comentarios, si te ha gustado espero tu like y alguna retroalimentación es muy importante para continuar haciendo estos ejemplos sencillos y básicos.

Nota: Esta forma de instalación no te permite manejar diversas versiones de **Node**, para eso requieres instalar por medio de NVM.

Nos vemos hasta la proxima.

## Fuentes

(1) [https://nodejs.org/es/about/](https://nodejs.org/es/about/)

(2) [https://docs.npmjs.com/about-npm/](https://docs.npmjs.com/about-npm/)
Interview Prep: Object Oriented Design Questions featuring Sam (@TechDebtor)
Tags: interview, career, oop, java
Published: 2020-03-05 00:34:31

Special guest Sam (https://dev.to/techdebtor) walks us through how to prepare for object oriented design questions and ace the communication and whiteboarding part of the interview.

This video is Part 1, in which we set up the problem and run through the design. See if you can come up with a solution before Sam posts (and explains!) the full code in Part 2.

Follow Sam on dev.to and twitter:
☆ https://dev.to/techdebtor
☆ https://twitter.com/techdebtor

CANDIDATE PLANET:
Empowering candidates to ace interviews and negotiate offers. We answer questions from anyone, and have had great results working with engineers, developer advocates, designers, marketers, managers, recruiters, and many more. 

Leave a comment or email ask@CandidatePlanet.com with questions you want us to answer.

SUBSCRIBE:
☆ Youtube ☆ https://youtube.com/channel/UCdvny6qs8e4VUJIG01puw2Q
☆ Newsletter ☆ https://dangoormendel.com/newsletter

MORE ABOUT US:
☆ Website ☆ https://dangoormendel.com
☆ Speaking Inquiries ☆ lusen@candidateplanet.com
☆ Client Inquiries ☆ hello@dangoormendel.com
☆ LinkedIn Lusen ☆ https://linkedin.com/in/lus
☆ LinkedIn Adam ☆ https://linkedin.com/in/adamdangoor
☆ Twitter Lusen ☆ https://twitter.com/staycalmcomic
☆ Twitter Adam ☆ https://twitter.com/AdamDangoor

{% youtube zjDzgWbJi9A %}
New features are a liability
Tags: softwaredevelopment, learninpublic
Published: 2020-03-05 00:19:19

New features are exciting. Users want them. Stakeholders want them. Designers and developers are excited to work on them. What’s not to like?

When it comes to adding a new feature, I know I've been susceptible to focusing on the benefit without considering the cost. The default is to ask, "Can we build it?" What doesn't always get asked is, "Should we build it?" Sure, adding features is a big part of building an app and growing a business, but it’s not all upside.

New features expand the surface area of your product. They [add complexity](https://github.com/papers-we-love/papers-we-love/blob/master/design/out-of-the-tar-pit.pdf). There is more that can break, which means more that needs to be maintained. There is more that a user needs to learn, which means on-boarding and retention can suffer. Sometimes new features are “bolted on” in a way that increases their maintenance beyond that of a feature that cleanly fits the existing architecture. ["Complexity has a way of compounding difficulties."](https://libquotes.com/fernando-j-corbat%C3%B3/quote/lby0a6b)

If you add features more quickly than you expand your capability for managing the cost (cost in the general sense, not just dollars) of those features, you’ll soon find yourself in the red. The tech debt will pile up. You’ll never seem to manage to bat down bugs as fast as they are coming in. Your app will drown. There is a dual nature to adding new features, a benefit and a liability. Add and remove accordingly.

---

Notes:

There are ways to manage the amount of software your team or business can be liable for. Many software tools and practices -- like testing, type systems, and OSS frameworks -- help reduce the liability of adding more code. Though I don't have much experience with this, large software companies suggest that staffing and organizational choices are a way to manage (and perhaps mismanage) this liability as well.