teleren/devto huggingface dataset:
JIRA from Beginner to Sprint Planning"!
Published: 2023-08-16 04:56:17

Are you ready to take your project management skills to the next level? 



Look no further! 📈 Introducing our brand-new YouTube video series: "JIRA from Beginner to Sprint Planning"! 📊



📺 In this comprehensive series, we will guide you through the ins and outs of JIRA, the industry-leading project management tool, and take you on a journey from the very basics to the art of Sprint Planning. Whether you're a newcomer to JIRA or looking to refine your Agile practices, this series is tailor-made for you!



🔥 What's in it for you?

🔹 Master the fundamentals of JIRA, making project management a breeze.

🔹 Dive deep into Agile methodologies and enhance your Sprint Planning prowess.

🔹 Learn time-saving tips, tricks, and best practices from experienced practitioners.

🔹 Gain a competitive edge in the job market by acquiring valuable skills.



Join us on this learning adventure and unlock a world of project management possibilities!

🌐 Don't miss out on this golden opportunity to boost your career and become a JIRA maestro!



🎥 Watch the first episode here:

https://www.youtube.com/watch?v=af8DdAFXskw&ab_channel=ResterTest



Stay tuned for regular updates as we unveil each episode in the series. Make sure to hit the "Subscribe" button and ring the notification bell so you never miss a beat! 🛎️



Tag a friend or colleague who needs to up their project management game and let's embark on this learning journey together! 🤝



#JIRA #Agile #ProjectManagement #SprintPlanning #CareerGrowth #LearningOpportunity #SkillBuilding #YouTubeSeries
Rhetorical virtual machines
Published: 2023-05-19 14:23:19

You are a cube.  You like things with the Right number of vertices.  You have opinions about how not-round your life circumstances should be.  Proper, tidy.  Some of your edges are rounded off with time, but generally you call yourself a cube and do cubey things.

They are a kidney-bean-shaped beanbag chair.  They are soft and have no vertices unless you simulate them at a low resolution with polygons.  The polygons at least give them some vertices so that they are more palatable to your need for edges and points.  You don't like the lack of square faces on those polygons, but they allow you to feel more secure that you understand this beanbag chair.  

How does your mind work?  Well, lets say it's like a virtual machine made up of very regular cubeish computational components.  Proper, tidy computational components.  You fit your square, cube, hypercube ideas about how to move your 6 faces through the world in to cubular instructions to calculate what your next move should be.  To generate an internal theory of mind for your round interlocutor so you can have a meaningful argument, you photograph the shapes they are waving in the air and feed those instructions in to your virtual machine.  The program crashes... of course.  Why can't they see that their ideas just don't work?

---

A person from group `A` understands their virtual machine, and they have useful simulations and projections of future outcomes that take advantage of the machine they run on.  They know they can tinker with certain values and get desired outcomes.  

`A` builds a simulation of what their interlocutor is proposing and runs it on their own virtual machine.  It doesn't crash because they constructed the simulation in ways that are consistent with their machine.  The outcomes differ from the outcomes proposed by the interlocutor and then they argue about this.  

`A` doesn't know how to build a simulation which will run on their interlocutor's hardware and most of the time won't even try.  That's hard.

What if `A` didn't even know that they had different hardware?
Is there any way to monitor micro task and macro task queue?
Tags: javascript, help, node
Published: 2023-08-16 04:35:26

I am looking for a way to monitor/visualize the JavaScript micro task and macro task queue like this view in the [answer](https://stackoverflow.com/a/43897778/6463558)

The microtask created by [`queueMicrotask`](https://developer.mozilla.org/en-US/docs/Web/API/queueMicrotask) API or Promise.

The macro task created by `setTimeout()`.

Is there any way?
What is Sanity use for? How to install Sanity?
Published: 2023-08-16 04:11:27

## What is Sanity use for?
Sanity allows you to build out your data and has the capability of editing images right on the interface. This eliminates a lot of time styling an image. For text values, you have the ability to style text or use a simple text box, which limits styling. This can then get implemented through schemas in your Next.
:film_projector: “Sanity Summer Release Event: Empowering Creators” goes live TODAY!
Tags: javascript, npm, sanity, devops
Published: 2023-08-16 03:56:52

In a few hours, we’re kicking off our summer release event on YouTube. We will talk about and show you all these summer’s releases like AI Assist, Visual Editing, Preview, and Perspectives. If you want to introduce someone to Sanity, we think this will be a good one to share with them — especially Content Creators who wonders what life in the Studio can be like. That being said, we hope that y’all will join us as well and hang out in the chat on YouTube. See you there!
6pm CEST / Noon EDT / 9am PDT

Head over to YT and make sure to subscribe to our channel to join the chat:
https://www.youtube.com/watch?v=6RT-oxc_uMM
Redux vs Redux-Tool kit
Tags: redux, react, webdev, javascript
Published: 2023-08-16 03:47:31

As we know in recent time how react is growing popularity in Tech Industry.Today we will be discussing about redux and its tool kit how ,when,where to use and differences how redux-tool kit helps redux to enhance the Application.

## What is Redux?
Redux is react popular state management library that handles state change thanks to Dan abramov for redux that makes our job easier and simpler to manage the state change.
Redux follow the Flux architecture and also follows centralized storage management.

## Redux ToolKit
Redux toolkit is simplified package that helps the Redux flow.
Redux has lot of boilerplate code while writing Like define actions,writing the reducer.

Lets see the difference  in code base when we use redux and when we use redux tool kit .Let take an example for counter using redux

## Counter Using Redux

```
const Increment='Increment'
const Decrement='Decrement'

const increment= () =>({type:Increment })
const decrement = () =>({type:Decrement})

const counterReducer = (state=0,action) =>{
switch(action.type){
case Increment:
  return state+1;
case Decrement:
  return state-1;
default:
return state;}
);
const {createStore}=Redux;
const store=creatStore(counterReducer);

store.dispatch(increment());
console.log(store.getState());

store.dispatch(decrement());
console.log(store.getState());

```

## Counter Using Redux-ToolKit

```
import {createSlice,configureStore} from '@reduxjs/toolkit'
const counterSlice=createSlice({
name:'counter',
intialState:'0',
reducer:(
increment:(state)=>state+1,
decrement:(state)=>state-1,
},
});
const store=configureStore({reducer:counterSlice.reducer});
store.dispatch(counterSlice.action.increment());
console.log(store.getState());

store.dispatch(counterSlice.action.decrement());
console.log(store.getState());
```
From the above notation code we can get to know the boilerplate code for redux when we have to initialize the state management but in redux toolkit we have in-build library of redux

## Advantages of Redux-ToolKit
**Reduce boilerplate code**
**Immutability Handling**
**Devtools Integration**

## When to use Redux

1. **Advance use cases-** In case if you are using Middleware,custom enhancer,manual control.
2. **Existing Redux codebase-** we can use redux if code base is already existing because shifting of codebase makes problematic.
🌐 Exciting Project Alert: Build Your Own Web-Based Translator! 🌐
Tags: html, css, javascript, api
Published: 2023-08-16 03:29:06



Hey fellow devs! 👋 Have you ever wanted to dive into web development and create something practical and fun? Introducing our latest project: a Web-Based Translator built using HTML, CSS, and JavaScript!

**🚀 Project Highlights:**

User-Friendly Interface: Crafted with HTML and styled with CSS, the user interface is sleek and intuitive.
Language Selection: Users can select source and target languages from dropdown menus.
Instant Translations: JavaScript makes it possible to fetch translations in real-time from translation APIs.
Live Demo: Check out our live demo [here](http://translator.sadiqmagbul.host20.uk/) and see how seamless language translation can be!

**🔧 How It Works:**

Input Text: Users type or paste text in the input area.
Language Selection: Choose source and target languages from dropdowns.
Translation Magic: JavaScript takes care of sending the text to translation APIs and updating the output area.


**🛠️ Tech Stack:**
HTML
CSS
JavaScript
Ready to give it a spin? Dive into coding and contribute to this open-source project on [GitHub ](https://github.com/sadiqshaik123/Translator). Let's break language barriers together!

Your coding journey awaits. Happy translating! 🌍🔤✨
Add plus one to the integer
Tags: javascript, interview, career, learning
Published: 2023-08-16 03:24:56


Good morning! Here's your coding interview problem for today.

## This problem was asked by Spotify.

**Given a non-negative integer represented as a non-empty array of digits, plus one to the integer.**

You may assume the integer do not contain any leading zero, except the number 0 itself.

The digits are stored such that the most significant digit is at the head of the list.

**Example**

```
function plusOne(digits){

};

console.log(plusOne([1,2,3])); // [1,2,4]
console.log(plusOne([4,3,2,1])); // [4,3,2,2]
```

**Solution**

```
function plusOne(digits) {
  let i = digits.length - 1;
  while (i >= 0 && digits[i] === 9) {
    digits[i] = 0;
    i--;
  }
  if (i === -1) {
    digits.unshift(1);
  } else {
    digits[i] += 1;
  }
  return digits;
}

console.log(plusOne([1, 2, 3])); // [1,2,4]
console.log(plusOne([4, 3, 2, 1])); // [4,3,2,2]

```

**Implementation**

- We start from the rightmost digit and keep adding one until we encounter a digit that is less than 9. This is because if the digit is 9, adding one would result in a carry-over to the next digit.
- If we encounter a digit less than 9, we simply increment it by one and return the updated array of digits.
- If we reach the leftmost digit and it was 9, we need to add a new digit at the beginning of the array before incrementing the leftmost digit. This is because adding one to 9 would result in a carry-over to the leftmost digit.
Comparing Changes with Git Diff
Tags: github, git, tutorial, webdev
Published: 2023-08-16 03:21:43

## Git Diff

- We can use the `git diff` command to view changes between commits, branches, files, our working directory, and more!
- We often use git diff alongside commands like git status and git log, to get a better picture of a repository and how it has changed over time.
- Without additional options, `git diff` lists all the changes in our working directory that are NOT staged for the next commit.
- `git diff --staged` will list the changes between the staging area and our last commit. You can think of it as "Show me what will be included in my commit if I run git commit right now"
- `git diff HEAD` lists all changes in the working tree since your last commit. It compares the HEAD and the working directory and shows both staged and unstaged changes.
- `git diff branch1..branch2` will list the changes between the tips of branch1 and branch2. The order matters as the first branch is referred to as File A and second as File B.
- To compare two commits, provide git diff with the commit hashes of the commits in question in the form of `git diff commit1..commit2`
- We can also view the changes within a specific file by providing git diff with a filename.
    
    ```bash
    git diff HEAD [filename]
    git diff --staged [filename]
    ```
    

## Reading Git Diffs

- For each comparison, Git explains which files it is comparing. Usually this is two versions of the same file.
- Git also declares one file as "A"(**old**) and the other as "B"(**new**).
    
    ### Markers
    
    - File A and File B are each assigned a symbol.
        - Changes in File A are indicated with a minus sign (-)
        - Changes in File B are indicated with a plus sign (+)
    
    ### Chunks
    
    - A diff won't show the entire contents of a file, but instead only shows portions or "chunks" that were modified.
    - A chunk also includes some unchanged lines before and after a change to provide some context
    - Each chunk starts with a chunk header, found between @@ and @@.
    - There are two sets of numbers in the chunk. One set belongs to File A and the other belongs to File B, that is what the sign indicates
    - The number with the sign indicates from which line no, the lines are extracted from and the second number indicates how many lines have been extracted.
    - From file a, 4 lines are extracted starting from line 3.
    - From file b, 5 lines are extracted starting from line 3
        
        
![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ynmfd4e3fjtoh14w6fv9.png)
         

### Changes

- Every line that changed between the two files is marked with either a + or - symbol and lines without any sign exist in both files
-     Simply the - can be interpreted as removed and + as added.
-     lines that begin with - come from file A
-     lines that begin with + come from file B
    
    

```bash
    diff --git a/rainbow.txt b/rainbow.txt
    index 72d1d5a..f2c8117 100644
    --- a/rainbow.txt
    +++ b/rainbow.txt
    @@ -3,4 +3,5 @@ orange
    yellow
    green
    blue
    -purple
    +indigo
    +violet
    
```
Day (17-2=15) of #100 days of health and study.
Tags: 100days
Published: 2023-08-16 02:28:59




Well, I'm making up my own rules, but I'm trying to be consistent.  Today would have been my 17 of #100 days of health and study, but I was sick on the weekend, so it shouldn't count.  Maybe I'm doing it wrong, but I'm going with it. 

## 15 of #100 days of health and study

I think a puffer fish is in my stomach.  When I got home, I was exhausted from work: is it mental or physical?  It can't be physical, as I didn't do anything physical other than surf a desk.  

So mental it is.  At this point, I need to do something physical before my day turns to crap.  Laundry needs to be finished, so I did that.  Helped a little.  Turned on the computer and decided to do some stretches and a 60-second plank.  I cheated after 15 seconds and went to my knees, but somehow I could still feel my stomach.  Did some triangles after that and I'm awake.  Damn it worked!

Off to do my studying, which I couldn't do when I was sick.  Tomorrow I'm going to do stretches in the morning and maybe a plank, but if not, then I'll do stretches after work and a plank.  It's good to have elastic goals according to Katy Milkman who studies behavior changes. 

Today is Project Cost Management.  I do this at work on my projects all the time, but this should be more in the weeds, or so they say.  Studying more in depth, the concepts I learned prior to my Project Plus Certification with formulas and math, etc. I like the weeds and I like the finances too.  Should be fun.  You know, my fear that this would start feeling like "work" hasn't materialized, and this creativity between work and study seems to help more than was anticipated.  As Seneca the Younger said, "We suffer more in imagination than in reality."

All the best.
Guía de bolsillo de PNPM
Tags: pnpm, npm, javascript
Published: 2023-08-16 02:15:51

# Primero la pregunta obligatoria ¿Qué es PNPM?

PNPM es una alternativa al tradicional gesto de paquetes NPM que viene por defecto al instalar Node.js. PNPM trae muchísimas ventajas con respecto a NPM que si quieres ver un poco más a detalle te recomiendo que veas [este video](https://youtu.be/0I8kiRbS4lI) de mi canal de YouTube.

# Guía de comandos

## Gestionar paquetes

Instalar paquetes:

```bash
  pnpm add <pkg>
```

Desinstalar paquetes:

```bash
  pnpm remove <pkg>
```

Actualizar los paquetes dentro del rango especificado:

```bash
  pnpm update
```

## Ejecutar scripts:

Ejecutar scripts del package.json:

```bash
  pnpm run
```

Ejecutar un paquete de manera remota sin instalarlo

```bash
  pnpm dlx create-react-app ./my-app
```

Crear un proyecto a partir de una plantilla de inicio:

```bash
  pnpm create vue@latest
```

# Manejar espacios de trabajo (environments)

Para poder ir cambiando con facilidad y rapidez de versiones de Node.js existe el comando:

```bash
  pnpm env
```

Que nos va a permitir ir seleccionando la versión de Node.js que queremos utilizar, por ejemplo:

```bash
  pnpm env use --global 18.9.1
```

Con este comando estaríamos especificando que queremos usar la versión 18.9.1 de Node.js y podemos utilizar este mismo comando para ir cambiando a diferentes versiones 👍🚀

# Conclusión

Bueno, en este post damos una guía de comandos que puedes consultar en cualquier momento a medida que te vayas acostumbrando a usar PNPM. Espero que te sea de mucha utilidad 😁

Si este post te ha gustado, puedes seguirme en mi canal de [YouTube](https://www.youtube.com/c/wiar8) en el cual subo contenido relacionado a la programación 🐢
Interactive UI Elements in SwiftUI
Tags: swift
Published: 2023-08-16 02:08:53

In this unit, we will delve into the interactive elements of SwiftUI. We will explore how to create and manage state, how to create interactive buttons, text fields, forms, sliders, switches, and pickers, and how to navigate between different screens in your application.

## Understanding State and Binding in SwiftUI

In SwiftUI, State and Binding are two property wrappers that are used to create a connection between the UI and the data. State is a source of truth for data in your app that can be mutated by the view. Binding provides a reference to a mutable state. When you need to modify a value from more than one place, you use a Binding.

## Creating Interactive Buttons

Buttons are the basic interactive elements in any application. In SwiftUI, you can create a button by providing an action and a label. The action is what happens when the button is tapped. The label is what’s shown on the button.
```swift
Button(action: {
    print("Button tapped!")
}) {
    Text("Tap me")
}
```
## Implementing Text Fields and Forms

Text fields are used to gather text input from the user. In SwiftUI, you can create a text field by binding it to a state variable. Forms are a collection of user input controls.
```swift
@State private var name = ""

var body: some View {
    Form {
        TextField("Enter your name", text: $name)
    }
}
```
## Using Sliders, Switches, and Pickers

Sliders, switches, and pickers are used to select from a range of values. In SwiftUI, you can create these controls by binding them to a state variable.
```swift
@State private var volume = 0.5

var body: some View {
    Slider(value: $volume)
}
```
## Understanding Navigation in SwiftUI

In SwiftUI, you can navigate between screens using a NavigationView and NavigationLink. A NavigationView is a view for navigating between pages of content. A NavigationLink is a button that navigates to another view when activated.
```swift
NavigationView {
    NavigationLink(destination: DetailView()) {
        Text("Go to Detail View")
    }
}
```
By the end of this unit, you should be able to create a variety of interactive UI elements and understand how to navigate between different screens in your application.
Basics of Application Layout with SwiftUI
Tags: swift
Published: 2023-08-16 02:07:29

SwiftUI, Apple's innovative and user-friendly interface toolkit, allows developers to design and interact with their app's UI in a more intuitive and efficient manner. In this unit, we will delve into the basics of application layout with SwiftUI.

## Understanding the SwiftUI Layout System

SwiftUI uses a layout system to position each view in your app's user interface. It provides a set of layout structures that automatically adapt to the device's screen size and orientation, ensuring your app looks great on all devices.

## SwiftUI Views and Modifiers

In SwiftUI, the basic building blocks of your user interface are views. A view is a piece of UI, like a button or a text field. You can modify the appearance and behavior of a view by applying modifiers to it. For example, you can change the text color of a button or make a text field accept only numeric input.

## Creating and Combining Views

Creating a view in SwiftUI is as simple as creating a new Swift struct that conforms to the View protocol. You define its body property to determine its content. For example:
```swift
struct ContentView: View {
    var body: some View {
        Text("Hello, SwiftUI!")
    }
}
```
You can combine multiple views to create more complex user interfaces. SwiftUI provides several view types that act as containers for other views, allowing you to group and coordinate the layout of multiple views.

## Building Complex User Interfaces with Containers

Container views in SwiftUI help you manage the layout of your user interface. The three primary types of container views are HStack, VStack, and ZStack, which arrange their child views horizontally, vertically, and in depth order (overlay), respectively.

For example, to create a vertical stack of three text views, you would write:
```swift
VStack {
    Text("Hello, SwiftUI!")
    Text("This is a VStack.")
    Text("It arranges its children vertically.")
}
```
## Using Stacks for Layout Design

Stacks are fundamental to layout design in SwiftUI. You can nest stacks within stacks to create complex layouts. For example, you might use a vertical stack to group several horizontal stacks, each representing a row in your layout.

By the end of this unit, you should be comfortable creating basic layouts using SwiftUI. You'll be able to create and modify views, combine them into complex user interfaces, and understand how SwiftUI's layout system works to arrange views on screen.
¿No conoces o no entiendes los patrones de diseño?
Tags: designpatterns, softwareengineering, architecture, performance
Published: 2023-08-16 02:04:42

Los patrones de diseños son soluciones habituales a problemas comunes en el desarrollo de software. Los patrones son como una plantilla que podemos ir personalizando para resolver problemas específicos en el código.

Si la forma de solucionar un problema se puede extraer, explicar y reutilizar en múltiples ámbitos y en muchas ocasiones, en ese caso nos hemos encontrado con un patrón de diseño.

Los patrones de diseño ayudan a estar seguro de que el código es válido y que funcionara, porque es una solución que utilizan millones de desarrolladores, por lo cual están más que probadas y testeadas.

Existen muchísimos patrones de diseños y distintas categorías de estos, y generalmente el punto más complicado de utilizarlos es saber identificar cuál debemos utilizar, por eso conocer la clase y uso de cada uno nos será de mucha utilidad.

Según la finalidad del patrón, estos se clasifican en tres tipos:

- Patrones Creacionales.
- Patrones Estructurales.
- Patrones de comportamiento.

Patrones Creacionales

Como su nombre indica, estos patrones vienen a solucionar o facilitar las tareas de creación o instanciación de objetos.

Algunos de los patrones creacionales más conocidos son:

- Factory.
- Abstract Factory.
- Factory Method.
- Builder.

Patrones estructurales

Los patrones estructurales nos ayudan a definir la forma en la que los objetos se componen.

Los patrones estructurales más habituales son:

- Adapter.
- Decorator.
- Facade.

Patrones comportamentales

Los patrones comportamentales nos ayudan a definir la forma en la que los objetos interactúan entre ellos.

Algunos de los más conocidos son:

- Command.
- Observer.
- Strategy.
- Template Method.