teleren/devto huggingface dataset:
Day 660 : Last Night
Tags: hiphop, code, coding, lifelongdev
Published: 2022-12-03 00:30:27

_liner notes_:
- Professional : Pretty chill day at work. The company has started back up the thing where we take a half day on Fridays. Did some work on a Web Component and reviewed a co-worker's blog post.

- Personal : Last night, I went through some tracks for the radio show and did some stuff on my side project.

![Aerial view looking down at the Big Sur, CA, USA coastline with waves crashing on the shore.](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zisdt689btm6zihgll7l.jpg)

Going to finish working on the radio show and then work on my side project. Maybe I'll finally start watching the "Wednesday" show on Netflix. Oh and I'll be on vacation next week so no blog post, but I'll still be doing the radio show at https://kNOwBETTERHIPHOP.com and my study sessions at https://untilit.works. Looking to get ahead with the radio show and make some progess on some ideas I have for projects.

Have a great night, weekend and week!

peace piece
Dwane / conshus
https://dwane.io / https://HIPHOPandCODE.com
{% youtube NA6Uk2kpCbM %}
Updates from the 93rd TC39 meeting
Tags: javascript
Published: 2022-12-02 23:45:50

There were several items on the agenda, this post focuses on feature proposals and their progress from the meeting that was held between 29th November to 1st December 2022

__Stage 4:__

* [Intl Enumeration API](https://github.com/tc39/proposal-intl-enumeration): Return supported values of options, such as timeZone, calendars, numberingSystems, currencies, units

__Stage 3:__

* [Set Methods](https://github.com/tc39/proposal-set-methods): Proposal for new Set methods.

* [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management): Address a common pattern in software development regarding the lifetime and management of various resources (memory, I/O, etc.).

* [Iterator Helpers](https://github.com/tc39/proposal-iterator-helpers): Methods for working with iterators.

* [Well-Formed Unicode Strings](https://github.com/tc39/proposal-is-usv-string): Method to determine if a String is well-formed Unicode.


__Stage 2:__

* [`eraDisplay` option for `Intl.DateTimeFormat`](https://github.com/tc39/proposal-intl-eradisplay): `Intl.DateTimeFormat` displays era field only if date displayed is in same era as today's.

* [Async Explicit Resource Management](https://github.com/tc39/proposal-async-explicit-resource-management): This proposal relates to async functionality deferred from the original Explicit Resource Management proposal and shares the same motivation.

* [ArrayBuffer.prototype.transfer](https://github.com/tc39/proposal-arraybuffer-transfer): This proposal is spun out of the resizable buffer's proposal.

__Stage 1:__

* [Mass Proxy Revocation](https://github.com/tc39/proposal-mass-proxy-revocation): Proposal for revoking proxies en masse.

* [Intl Era and MonthCode](https://github.com/tc39/proposal-intl-era-monthcode): To specify necessary details about era, eraYear and monthCode usage with Temporal in internationalization setting (for calendars other than "iso8601").


* [Intl.MessageResource](https://github.com/eemeli/proposal-intl-message-resource): This proposal aims to make it easier to localize the web, increasing the openness and accessibility of the web for speakers of all languages.

<hr />

<center><b>[@gnumanth](https://twitter.com/gnumanth)<b></center>
Writing better README.md files using GitHub flavoured markdown
Tags: git, github, markdown, documentation
Published: 2022-12-02 23:18:25

## Introduction

GitHub flavoured markdown is a set of extensions to the standard markdown syntax that gives you some cool features to make your README.md files look great on GitHub. In this article, we'll look at some of the features that GitHub flavoured markdown has to offer and how you can use them in your own README.md files.

## README.md Formatting

### Headings

GitHub flavoured markdown supports two types of headings: setext and atx.

Setext headings are created by underlining the heading text with `=` for h1 headings and `-` for h2 headings. For example:

```
This is an H1
=============

This is an H2
-------------
```

Atx headings are created by surrounding the heading text with `#` characters. The number of `#` characters you use determines the heading level, with `#` being h1, `##` being h2, `###` being h3, and so on. For example:

```
# This is an H1

## This is an H2

### This is an H3

#### This is an H4

##### This is an H5

###### This is an H6
```

### Lists

GitHub flavoured markdown supports both ordered and unordered lists.

Ordered lists are created by prefixing the list items with numbers followed by a period. For example:

1. First item
2. Second item
3. Third item

Unordered lists are created by prefixing the list items with `-`, `+`, or `*`. For example:
This

```
- First item
- Second item
+ Third item
* Fourth item
```

will create these:
- First item
- Second item
+ Third item
* Fourth item


### Images

Images are created by surrounding the image URL with `![](...)`. The text inside the `[...]` is used as the image alt text. For example:
 ```
![GitHub Logo](/images/logo.png)

```

### Code Blocks

Code blocks are created by surrounding the code with blocks of 3 (`) . For example:

```
function foo() {
  console.log("foo");
}
```

### Tables

Tables are created by using the `|` character to create columns and the `-` character to create rows. For example:

These:
`
| Column 1 | Column 2 | Column 3 |
|----------|----------|----------|
| Row 1    | Row 2    | Row 3    |
| Row 4    | Row 5    | Row 6    |
`
will create these:

| Column 1 | Column 2 | Column 3 |
|----------|----------|----------|
| Row 1    | Row 2    | Row 3    |
| Row 4    | Row 5    | Row 6    |

### Emoji

GitHub flavoured markdown supports emoji! :smile: To use emoji, simply type the emoji code :smile: and it will be replaced with the emoji image. For example, `:smile:` will be replaced with 

```
![](https://github.githubassets.com/images/icons/emoji/unicode/1f604.png).
```

## Conclusion

GitHub flavoured markdown is a great way to make your README.md files look great on GitHub. In this article, we've looked at some of the features that GitHub flavoured markdown has to offer and how you can use them in your own README.md files.

## Resources

- [GitHub Flavored Markdown Spec](https://github.github.com/gfm/)
- [Emoji Cheat Sheet](https://www.webpagefx.com/tools/emoji-cheat-sheet/)
SPVM::IO 0.14 is released on Perl/CPAN
Tags: spvm, perl, cpan
Published: 2022-12-02 23:14:41

<a href="https://metacpan.org/pod/SPVM::IO">SPVM::IO</a> 0.14 is released on Perl/CPAN.

## New Features and Enhancement

<a href="https://github.com/yuki-kimoto/SPVM-IO/blob/master/Changes">Changes</a>

```
0.14 2022-12-03
  [Prerequrement Changes]
    * SPVM::IO needs SPVM 0.9664+.
    * SPVM::IO needs SPVM::Sys 0.28+.
  [Incompatible Document Changes]
    * Removed the is_io_handlable method in the IO::Handle class in the doc.
      This was removed in the past.
  [Document Improvement]
    * Added the doc of the IO::Handle.
    * Added the doc of the IO::Handle::Interface.
  [Incompatible Changes]
    * Removed the autoflush method in the IO::File class.
    * Removed the get_autoflush in the IO::Handle class.
    * Changed the definitions of the following fields in the IO::Handle class.
      [Before]
      has autoflush : wo byte;
      [After]
      has autoflush : rw byte;
```
Valores em Binário, Octal e Hexadecimal em Python
Tags: python, beginners, tutorial, braziliandevs
Published: 2022-12-02 23:09:06

Fazer a conversão de um número decimal para o seu valor em binário, octal ou hexadecimal é mais fácil do que parece. Uma forma simples de fazer isso é usando diretamente as funções ``bin``, ``oct`` e ``hex``:

```py
n = 97

print(bin(n))
print(oct(n))
print(hex(n))
```

Resultado:

```py
0b1100001
0o141
0x61
```

Repare que temos dois dígitos de padronização no início dos resultados da conversão, para ser exibido apenas o resultado de fato, podemos fatiar da seguinte maneira:

```py
n = 97

print(bin(n)[2:])
print(oct(n)[2:])
print(hex(n)[2:])
```

Resultado:

```py
1100001
141
61
```
Advent.js🎅🏼| Reto #2: Nadie quiere hacer horas extra
Tags: javascript, typescript, spanish, adventofcode
Published: 2022-12-02 21:44:34

## [Nadie quiere hacer horas extra](https://adventjs.dev/es/challenges/2022/2)

Un millonario ha comprado una red social y no trae buenas noticias. Ha anunciado que **cada vez que una jornada de trabajo se pierde por un día festivo**, habrá que compensarlo con **dos horas extra otro día de ese mismo año**.

Obviamente la gente que trabaja en la empresa no le ha hecho ni pizca de gracia y están **preparando un programa que les diga el número de horas extras que harían** en el año si se aplicara la nueva norma.

Al ser trabajo de oficina, su horario laboral es de **lunes a viernes**. Así que sólo tienes que preocuparte de los días festivos que caen en esos días.

Dado un año y un array con las fechas de los días festivos, devuelve el número de horas extra que se harían ese año:

```js
const year = 2022
const holidays = ['01/06', '04/01', '12/25'] // formato MM/DD

// 01/06 es el 6 de enero, jueves. Cuenta.
// 04/01 es el 1 de abril, un viernes. Cuenta.
// 12/25 es el 25 de diciembre, un domingo. No cuenta.

countHours(year, holidays) // 2 días -> 4 horas extra en el año
```

Cosas a tener en cuenta y consejos:

* El año puede ser bisiesto. Haz las comprobaciones que necesitas para ello, si fuese necesario.
* Aunque el 31 de diciembre sea festivo, las horas extra se harán el mismo año y no el siguiente.
* El método `Date.getDay()` te devuelve el día de la semana de una fecha. El 0 es domingo, el 1 es lunes, etc.

Completa el reto!

---

Puedes seguir a @midudev y estar pendiente de los retos de Advent.js 

{% twitter 1597965996383412225 %} 

---

Mi solución:


{% jsitor https://jsitor.com/embed/zkTh_w9R0K %}
"...learn as if you are going to live forever..."
Published: 2022-12-02 22:59:59

Greets. I'm Mario "M@RZ" Armstrong, and I'm a lifelong learner. It's not like I'm going back to school to escape life; just the reverse, in fact. I came to realize that as life changes seasonally, we must adapt to it. I currently have a lot of life experience thanks to my military career, travels, previous marriage, and having children. I realize more and more as I, ahem, age older that being tech savvy is just as crucial as spending time in the sun each day. As a result, I have successfully finished the AWS Re/Start program and am now advancing via Cloud Academy to learn JavaScript. You might say that I wish to write on the clouds! Meta-Tagging!
【Windows】Difference between User Environment Variables and System Environment Variables
Tags: windows
Published: 2022-12-02 22:53:51

When you install new language into your PC (e.g. PHP) , you need to register the path to its directory to set an environment variable for it.

If you set this variable, you will be able to use the command (such as "php") in your command prompt to order to your program. Otherwise, you will get the message that says "XXX is not recognized as an internal or external command."

There are 2 types of environment variables.
##1.User Environment Variables##
This is user-specific. It works only for the account that set this variable.

##2.System Environment Variables##
This is available for all users.
How to Clone, Commit, and Push to a Git Repo
Tags: github, git, beginners, tutorial
Published: 2022-12-02 21:29:17


Cloning a git repo is one of the first steps to getting started with a new project or working on an existing project. It allows you to download a copy of an existing repository from a remote server and start making modifications. In this article, we'll go over how to clone a git repo, create a new branch, commit to the new branch, and then push the branch to the remote server. For this example we will use [GitHub](https://github.com/) as the remote server.

## Cloning the Repo

To begin, open your terminal and navigate to the directory where you want to clone the git repo. Then, run the following command, replacing “[repo name]” with the name of the repository you want to clone. An example of a repo name is `chand1012/blog` .

```bash
git clone https://github.com/[repo name].git
```

This will download the entire repository to your local machine.

## Creating a New Branch

Next, you'll want to create a new branch to work on. A branch can be thought of as a slightly different version of the source code that has the same starting history. The ultimate goal is to eventually merge the new branch back into the primary branch, usually called “main” or “master”. To do this, run the following command from within the repository's directory:

```bash
git checkout -b [branch name]
```

Replace “[branch name]” with the name you'd like to give your new branch.

## Adding & Committing Files

Now, you can start making changes to the repository and committing them to the new branch. To do this, first make your changes, then run the following command:

```bash
git add -A
```

Once the files have been added, you can commit the changes with the following command:

```bash
git commit -m "[message]"
```

Replace “[message]” with a brief description of your changes.

## Pushing the Branch

Finally, you can push the new branch to the remote server with the following command:

```bash
git push -u origin [branch name]
```

Replace “[branch name]” with the name of your new branch.

And that's it! You've successfully cloned a git repo, created a new branch, committed to the new branch, and pushed the branch to the remote server.
Intro to Micro Front Ends
Tags: microfrontends, react, modulefederation, webpack
Published: 2022-12-02 23:45:43

---
title: Intro to Micro Front Ends
published: true
date: 2022-12-02 21:02:18 UTC
tags: microfrontends, react, modulefederation, webpack
canonical_url: https://okhivrych.io/intro-to-micro-front-ends
---

Architecting micro-frontends can be challenging. The right micro-frontends approach can provide many benefits for organisations. But the poorly architected system can sometimes lead to many critical issues (performance, complexity, big cognitive load).

In this talk, I will explore how we can keep micro frontends simple with the help of Module Federation and enable independent release flows in modern web applications.

### This talk will cover the following:

- What are micro frontends?
- Benefits and risks
- Overview of modern modular monolith web apps
- Enabling distributed frontends using Module Federation
- Live Demo of Client Side Rendering with Module Federation
- Live Demo Server Side Rendering with Module Federation

https://www.youtube.com/watch?v=lV-X6byaE2E
Delete all node_modules folders from your system ? 🤔
Tags: node, javascript, webdev, typescript
Published: 2022-12-02 20:52:00

![Image meme for how big a node_modules can be](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wdzf0a5xo5r0qula61rx.png)


Is it giving you hard time to remove `node_modules` folders from each of your project ? 🙈

Or

You never delete `node_modules` after finishing project due to the tedious work nature ? 🙊

Or

Maybe you forget to delete it most of the time ? 🙉


---

## NO WORRIES!!! 🎉


We have one simple command to delete `node_modules` folders inside a particular folder... or to delete all `node_modules` from the system then run from home directory 🔥

```bash
npx npkill
``` 


![Image how npkill works](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/i71od15daoa0g0so2x1y.gif)

>Boom! 💥, that's it.. run this command and it shows a **list** of the `node_modules` directories in your system, as well as the size they take up. Then you can select using _arrow keys_ and _spacebar_  to erase it **fast**, Yay!

---


For more details check ➡️ [here](https://www.npmjs.com/package/npkill)


{% link https://dev.to/mnathani/two-lines-of-css-that-boosts-7x-rendering-performance-4mjd %}
openpgp proof
Published: 2022-12-02 20:47:35

---
title: openpgp proof
published: true
description: 
tags: 
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2022-12-02 20:47 +0000
---

openpgp4fpr:4E5DC0D7B51CF6AB3664FCD83C185ED56E760F73
Embaralhando e Sorteando em Python
Tags: python, beginners, tutorial, braziliandevs
Published: 2022-12-02 20:14:16

Embaralhar pode ser uma função interessante em um programa, ainda mais se queremos garantir mais aleatoriedade em um conjunto de dados que serão escolhidos.

Importaremos a biblioteca ``random`` e criaremos uma lista de inteiros para ser usada em nosso exemplo.

```py
import random
lista = [10,20,30,40,50]
```

E por fim, para embaralhar a lista, usaremos a o método ``shuffle``. Se exibirmos a lista, poderemos ver os elementos embaralhados.

```py
random.shuffle(lista)
print(lista)
```

Exemplo de resultado:

```py
[50, 40, 20, 10, 30]
```

E para fazer uma escolha aleatória, usamos o método ``choice``.

```py
x = random.choice(lista)
print(x)
```

Exemplo de resultado:
```py
30
```
What was your win this week?
Tags: discuss, weeklyretro
Published: 2022-12-02 20:06:47

Hey folks! 👋

Hope y'all all are having a fantastic Friday and that you enjoy your weekends!

Looking back on this past week, what was something you were proud of accomplishing?

All wins count — big or small 🎉

Examples of 'wins' include:

- Starting a new project
- Fixing a tricky bug
- Dancing with your friends! 🕺

---

![90's kid dance party](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cij8a3ee81n2yonnu6nt.gif)
Web 3.0 in a nutshell
Tags: web3, webdev, programming
Published: 2022-12-02 20:05:58

Web 3.0 is a term that is used to describe the future evolution of the World Wide Web. It refers to a vision of the web where the focus is on making the web more intelligent and capable of better understanding the meaning and context of the data that is published on it. This is achieved through the integration of semantic technologies, such as ontologies and metadata, and intelligent agents, which are software programs that can autonomously perform tasks on behalf of users.

Web 3.0 is still a concept that is under development and is not yet fully realized. However, some of the key features of Web 3.0 include:

- The use of semantic technologies helps to describe and classify the data on the web in a way that allows machines to better understand its meaning and context. This makes it possible for computers to automatically process and analyze large amounts of data, and to provide more useful and relevant information to users.
- The use of intelligent agents, which are capable of learning from user behavior and preferences, can be used to personalize web experiences and provide more tailored and relevant content to users.
- The integration of web-based services and applications, which can be accessed and used from any device and location, can provide users with a seamless and consistent experience across different platforms and devices.

Overall, the goal of Web 3.0 is to make the web more intelligent, efficient, and user-friendly, and to enable new applications and services that were not possible with previous generations of the web. It is a concept that has the potential to greatly enhance the way we use and interact with the web in the future.
How to use the 'forkJoin' RxJS operator
Tags: javascript, angular, rxjs, rxjsoperators
Published: 2022-12-02 19:13:53

### Overview

There are times where you will want one observable stream, that contains data from multiple observable sources. This can be accomplished by utilizing the forkJoin RxJs operator to combine multiple observable streams into one.

### Getting Into It

Open an app to the component that needs to have the observables combined, or create a sandbox Angular app. Knowing what an observable is and how to create/use them is necessary to use forkJoin. If observables are a new concept, do some research about that first.

For this example I'm going to use a <a href="https://stackblitz.com/edit/angular-ivy-8wujh2?file=src%2Fapp%2Fapp.component.ts" target="#"> StackBlitz </a> and calling the <a href="https://pokeapi.co" target="#">PokeApi</a> for my observables. In the component create an array of the HTTP calls, but don't subscribe to each observable. That should look something like the example below:

```ts
// app.component.ts

export class AppComponent implements OnInit {
  private pokeApiBaseUrl = "https://pokeapi.co/api/v2";
  public pokeData$: Observable<any>;

  constructor(private _http: HttpClient) {}

  ngOnInit() {
    const pokemonData = [
      this._http.get(`${this.pokeApiBaseUrl}/pokemon`),
      this._http.get(`${this.pokeApiBaseUrl}/type`),
      this._http.get(`${this.pokeApiBaseUrl}/generation`),
    ];
    this.pokeData$ = forkJoin(pokemonData).pipe(
      tap((pokeData) => console.log({ pokeData }))
    );
  }
}
```

As you can see, the 'pokemonData' array is created with three observables by creating an HTTP call for each one. Then when the array is passed into forkJoin, each HTTP call is made in order and the three calls are compiled into one observable. This resulting observable can be seen by tapping into the pipeline like I do above. 
** Note, the observable will not resolve until all http calls have been completed in the input array into forkJoin. This could be useful when trying to do something in order **

Once the pokemonData array is passed into forkJoin, you can treat it as a normal observable. As you can see above, I tap into the pipeline and console.log the result. First though you must make sure to subscribe to the forkJoin. In this example I do so by using the async pipe, but this can also be done by using `.subscribe()`. Another good thing to know about this operator is that the resulting Observable will always be an array, and the order of the array will always be in the same order as when you passed them in to the forkJoin.

### Wrap Up

This can be a very valuable RxJS operator to utilize. Often times having code execute in order, or to be able to combine all the observables into one observable, can be extremely useful. In those situations forkJoin is a great way to accomplish that.

For a live example of the above code, see <a href="https://stackblitz.com/edit/forkjoin-example-blamb31?file=src%2Fapp%2Fapp.component.ts" target="#"> this StackBlitz </a>