teleren/devto huggingface dataset:
Por que utilizar RxJS no desenvolvimento de aplicações Angular?
Tags: rxjs, webdev, functionalreactiveprogramming
Published: 2023-08-23 02:38:26


Se você está se aprofundando no mundo do Angular, inevitavelmente já se deparou com o termo "RxJS". Mas o que é o RxJS? E por que ele é tão entrelaçado com Angular? Neste post, vamos explorar essas questões e entender as vantagens de utilizar o RxJS em aplicações Angular.

## 1. O que é RxJS?

RxJS é a abreviação para Reactive Extensions for JavaScript. É uma biblioteca para programação reativa usando observáveis, tornando mais fácil compor código assíncrono ou baseado em callbacks. Em essência, oferece uma maneira de você manipular sequências de eventos ao longo do tempo.

## 2. Integração Natural com Angular

Angular e RxJS são frequentemente usados juntos. A equipe de desenvolvimento do Angular adotou o RxJS devido à sua robustez no tratamento de operações assíncronas. Vários aspectos do núcleo do Angular, como o módulo HttpClient e o sistema de Roteamento, utilizam RxJS.

## 3. Vantagens de usar RxJS em Angular

**a) Manipulação Simplificada de Operações Assíncronas**: Em aplicações web modernas, frequentemente precisamos lidar com operações assíncronas - seja chamando uma API, aguardando a resposta do usuário ou lidando com eventos em tempo real. RxJS fornece ferramentas para gerenciar essas situações de forma limpa e legível.

**b) Composição Elegante**: Com os operadores RxJS, você pode facilmente combinar, filtrar, transformar e manipular múltiplas sequências de eventos. Isso resulta em um código mais organizado e manutenível.

**c) Facilita o Gerenciamento de Estado**: Em aplicações de grande escala, o gerenciamento de estado torna-se crucial. Com o padrão Observable, é mais fácil gerenciar e reagir às mudanças de estado ao longo do tempo.

**d) Melhoria na Performance com Lazy Loading**: Observables são "lazy" por natureza, o que significa que são ativados apenas quando um observador se inscreve. Isso permite carregar dados ou executar operações apenas quando necessário, otimizando a performance.

**e) Cancelamento de Subscrições**: Uma das características mais poderosas do RxJS é a capacidade de cancelar subscrições. Quando uma operação assíncrona não é mais necessária (por exemplo, uma solicitação HTTP que demora muito), é possível cancelá-la, evitando efeitos colaterais indesejados e otimizando recursos.

**f) Consistência no Tratamento de Erros**: A programação reativa no RxJS permite tratar erros de uma maneira uniforme, independente de sua origem, seja uma API, um timer ou um evento do usuário.

## 4. Conclusão

O uso do RxJS em aplicações Angular não é apenas uma moda passageira, mas uma decisão arquitetônica que traz consigo uma série de benefícios. A combinação dessas duas poderosas ferramentas oferece uma plataforma robusta para desenvolver aplicações web modernas, reativas e eficientes.

Se você ainda não mergulhou no mundo do RxJS, agora é a hora. Sua jornada com Angular será muito mais rica e produtiva ao adotar os princípios e práticas da programação reativa que o RxJS oferece.

---
Hi everyone ✨
Published: 2023-08-23 02:35:42

Hello developer community✨, I need your help participating in my repository is incredibly easy🐥
Your collaboration would help me a lot since this is graded for me in the academy🏫
I hope you can add it in your favorites⭐
thank you very much from the heart ❤️


https://github.com/santimars/Tell_me_about_yourself
Deno on Fresh 1.4 Adds FTL Drives 🚀
Tags: deno, rust, webdev, performance
Published: 2023-08-23 02:34:23

I hereby confirm Fresh 1.4's perf-improvements are legit!

## Fresh 1.1

```sh
❯ wrk -t12 -c400 -d10s http://www.russbrooks.com
Running 10s test @ http://www.russbrooks.com
  12 threads and 400 connections
Requests/sec:    121.80 👈
```

## Fresh 1.4.2

```
❯ wrk -t8 -c500 -d10s http://www.russbrooks.com
Running 10s test @ http://www.russbrooks.com
  8 threads and 500 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    27.93ms   38.66ms 514.91ms   93.96%
    Req/Sec     1.34k     0.98k    3.60k    65.40%
  105725 requests in 10.07s, 19.96MB read
  Socket errors: connect 253, read 0, write 0, timeout 0
Requests/sec:  10495.36 👈 🚀 🚀 🚀 🚀
```

That jives with the [numbers here](https://github.com/BuilderIO/framework-benchmarks), where Fresh placed second-fastest framework.

## Lighthouse Score

Equally incredible!

![Lighthouse Score](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/heqlv4gxvdz0bmfoxeka.png)

Hosted on a **free** account at [Deno Deploy](https://deno.com/deploy). Imagine what the numbers would be on Enterprise-class infra. This means we finally have Fire-and-Forget websites, because a single Node is able to handle a 10X more traffic than your Ruby/Node/Python ones. No more scrambling to scale every 8 weeks, after your team launches 1.0, having to answer pages at 3 AM because your Scripting-Language just collapsed at 500 R/s, then again at 1,000 2 mo later, then 1,500 2 mos later, then 2,000, then 2,500, etc.

> Our Rust boxes never trigger PagerDuty.

-- [Steve Klabnik](https://steveklabnik.com/)

I'm really pleased with the whole Deno experience, from toolset, to perf, to pkg mgmnt, to sensible defaults, to the TypeScript Std Lib that's bundled, to the Edge-First global deployment you get free.
Primeiros Passos com Observáveis
Tags: rxjs, webdev, functionalreactiveprogramming
Published: 2023-08-23 02:16:13

Os observáveis são uma forma poderosa de lidar com sequências assíncronas de eventos, amplamente utilizados em frameworks e bibliotecas como o Angular e a biblioteca RxJS. Ao compreender os observáveis, você pode aproveitar uma abordagem reativa para lidar com dados assíncronos, como chamadas HTTP, entradas de usuário, entre outros.

Vamos dar uma olhada em como criar um observável, inscrever-se para escutar as mudanças e, finalmente, como se desinscrever.

**1. Criando um Observável**
Para criar um observável, primeiro você precisará da biblioteca RxJS. Se ainda não a tem instalada, faça-o via npm ou yarn:


```
npm install rxjs
```

Agora, você pode criar um observável:


```
import { Observable } from 'rxjs';

const meuObservavel = new Observable(subscriber => {
  subscriber.next('Olá');
  subscriber.next('Mundo');
  setTimeout(() => {
    subscriber.next('com delay!');
    subscriber.complete();
  }, 2000);
});
```

Neste exemplo, o observável emitirá "Olá", "Mundo" e, após 2 segundos, "com delay!" e, em seguida, será completado.

**2. Inscrevendo-se em um Observável**
Para escutar as mudanças ou os eventos emitidos por um observável, você precisa se inscrever nele:


```
const inscricao = meuObservavel.subscribe(
  valor => console.log(valor), // função que lidará com os valores emitidos
  erro => console.error(`Erro capturado: ${erro}`), // função que lidará com erros
  () => console.log('Observável completado!') // função chamada quando o observável estiver completo
);
```

Ao rodar este código, você verá as mensagens no console conforme os valores forem emitidos.

**3. Desinscrevendo-se de um Observável**
É vital se desinscrever de observáveis para evitar vazamentos de memória ou comportamentos inesperados. A chamada de subscribe retorna uma inscrição, que você pode usar para se desinscrever:

```
inscricao.unsubscribe();
```

Normalmente, você se desinscreverá em situações como:

Quando um componente em frameworks como Angular é destruído.
Quando você sabe que não há mais nenhum valor útil sendo emitido.

Antes de se inscrever novamente no mesmo observável.
E é isso! Com estes primeiros passos, você está no caminho certo para explorar o mundo dos observáveis e da programação reativa. Os observáveis são uma ferramenta incrivelmente poderosa e, à medida que você se aprofunda neles, descobrirá operadores e padrões avançados que podem transformar a maneira como você lida com eventos assíncronos no seu código.
Introdução ao RxJS: Entendendo a Programação Reativa
Published: 2023-08-23 02:00:52

**O que é programação reativa?**
A programação reativa é um paradigma de programação que trata os fluxos de dados e a propagação das mudanças como cidadãos de primeira classe. Em outras palavras, é uma abordagem onde você programa com fluxos de dados assíncronos. Se já ouviu falar em "streams" ou "observáveis", você está no caminho certo.

Nesse modelo, ao invés de você dizer passo a passo o que seu código deve fazer (como na programação imperativa), você define uma reação a determinadas mudanças ou eventos. Pense nisso como criar uma série de reações em cadeia: quando um valor muda, ele automaticamente desencadeia uma reação em outro lugar do seu código.

**Por que usar o RxJS?**
RxJS (Reactive Extensions for JavaScript) é uma biblioteca para programação reativa usando observáveis, tornando possível representar fluxos de dados assíncronos de maneira muito mais simples e elegante. Aqui estão algumas razões pelas quais você pode considerar usar RxJS:

**Manipulação de Eventos Assíncronos:** Em aplicações modernas, muitas vezes precisamos lidar com múltiplos eventos assíncronos, como chamadas de API, interações do usuário ou eventos do sistema. RxJS fornece uma maneira coesa de trabalhar com esses eventos, tratando-os como fluxos contínuos de dados.

**Poderosas Operações de Stream:** RxJS vem com uma ampla gama de operadores que permitem transformar, combinar, filtrar e manipular streams de dados. Isso é semelhante ao que podemos fazer com arrays em JavaScript, mas aplicado a fluxos de dados assíncronos.

**Melhor Gerenciamento de Recursos:** Um dos desafios ao lidar com operações assíncronas é o gerenciamento de recursos, como cancelar uma chamada HTTP não desejada. RxJS torna isso mais simples através do conceito de "desinscrição", permitindo que você gerencie e limpe recursos de maneira eficiente.

**Código Mais Legível:** Ao usar o RxJS, o código muitas vezes se torna mais declarativo. Você define o que quer que aconteça em resposta a mudanças, em vez de como isso deve acontecer. Isso pode levar a um código mais limpo e fácil de entender.

**Integração com Frameworks Populares:** Muitos frameworks e bibliotecas populares, como Angular, já integram ou têm uma fácil integração com o RxJS, facilitando a adoção em projetos existentes.

**Conclusão**
O RxJS oferece uma poderosa abordagem para lidar com operações assíncronas e eventos em JavaScript, embasado no paradigma da programação reativa. Se você está buscando uma maneira de lidar com a complexidade crescente das interações assíncronas em suas aplicações, vale a pena considerar a adoção do RxJS e a programação reativa como ferramentas no seu arsenal de desenvolvimento.
Object-Oriented Programming Principles in the Context of Soccer
Published: 2023-08-23 01:53:41

## Abstraction
Abstraction involves focusing on the essential aspects of an object and hiding irrelevant details.

```
class Player {
    private String name;
    private String position;
    private String skill;

    public Jugador(String name, String position, String skill) {
        this.nombre = nombre;
        this.posicion = posicion;
        this.habilidades = habilidades;
    }

    public String getName() {
        return name;
    }

    public String getPosition() {
        return position;
    }

    public void setSkill(String skill) {
        this.skill= skill;
    }
}
```

> We could have a class called 'Player' that represents the players in a team. This class could abstract away the details about the player's physical appearance and focus on properties such as their name, position on the field, and skills.
Manager Handbook for Centralized AntDB-T — P7–2
Published: 2023-08-23 01:53:05

DDL flashback
This section describes the use of the recycle bin.
Turn on the adb_trashcan switch
1.Parameter configuration

```
Add configuration items to "postgresql.conf" in all nodes, as follows:
adb_trashcan.enable = on
```
You need to restart the node to take effect after the configuration is done.
1.Check if the plugin is loaded

```
show adb_trashcan.enable;
```
Retrieve deleted tables
The data of tables deleted by drop table and truncate table will be placed under the shcema of adb_trashcan, and the deleted data can be retrieved in this mode, and the name of the table is "table_name_time_deleted".

```
set search_path = 'adb_trashcan';
\d
```
If the tables in adb_trashcan mode are dropped and truncated, they are actually deleted and cannot be retrieved.
Once the deleted table is found in the recycle bin, it can be restored to its original location by calling the function:

```
select flashbackddl('Original table name', 'The name of the table in the Recycle Bin');
```

For example:

```
select flashbackddl('t1', 't1_timestamp');
```

If you want to empty the recycle bin once and for all, you can recreate and extend the antdb_flashback.


```
drop extension antdb_flashback cascade;
create extension antdb_flashback;
```

Close recycle bin
1.Remove configuration entries in postgresql.conf.

```
adb_trashcan.enable = off
```
1.Restart the node or reload configuration.
Turn off the flashback switch
as introduced earlier the DDL flashback switch has a special parameter adb_trashcan.enable, turning off this parameter will turn off the DDL flashback function alone, if you want to further turn off the DML flashback function, the following operation is also required.
1.Remove the antdb_flashback extension

```
drop extension antdb_flashback cascade;
```
1.Remove the antdb_flashback configuration from shared_preload_libraries.
2.Restart the database.
Usage restrictions
•Currently only DML statements of tables, drop table and truncate table statements can be flashed back.
•Tables with inheritance relationships are not supported by DDL flashbacks.
•Tables with sequences and constraints are not supported by DDL flashbacks.
•For partition tables, DDL flashback only supports those with two levels.
A Bit About My Background
Tags: ruby, rails, webdev, javascript
Published: 2023-08-23 01:23:38

My journey into web development began quite a while ago, and I can still recall my earliest learning experiences through resources like W3Schools and a site called "Dave's Site." While I'm not sure if the latter still exists, it was the first tutorial I ever followed.

Since those beginnings, I've been navigating my way through the world of web development. After completing college, I didn't immediately step into a Software Engineer role. Instead, I found myself working with a SaaS (Software as a Service) company before the SaaS industry truly took off.

This experience was somewhat advantageous, as it motivated me to continue my independent learning journey. It also served as a stepping stone before I officially launched my career as a Software Engineer. The path wasn't always straightforward, and I certainly had to put in significant effort before making headway in this field.
How can we make it easier for newcomers to contribute to open source?
Tags: webdev, beginners, programming, opensource
Published: 2023-08-23 01:15:51

Is it just me, or do others also find that the initial steps to contribute to open-source projects can feel quite daunting? Especially for beginners who are just starting out, the path forward can be unclear. While I might not have all the specifics, it's clear that there's a need for more effective methods to match individuals with the right projects based on their interests and skill levels.

GitHub undoubtedly serves as an excellent platform for discovering projects, and additional resources are available as well. Labels like 'beginner-friendly' and 'good first issue' provide valuable guidance. However, even with these aids, the process can still pose significant challenges, often involving understanding the project and configuring the development environment. Additionally, there's sometimes a race to be the first to comment and get assigned to an issue.

I often find myself wondering about potential tools that could be developed to make this process more efficient. For instance, envision resources that simplify project comprehension and environment setup, or mechanisms that enhance the fairness of issue allocation. The idea of such tools is indeed exciting and holds the potential to make the open-source contribution experience more accessible to a broader range of individuals.
An Introduction...
Published: 2023-08-23 01:09:43

Hello dev.to! My name is Joe, and I go by thtmexicnkid on most, if not all, [social media platforms](https://allmylinks.com/thtmexicnkid). I am fairly new to blogging and this is an exciting opportunity to express some creativity in a new way.

In my personal life, I am many things -- a drummer in a local Detroit hard rock band, a gamer and Twitch streamer, a n00b wrestling fan, and, maybe most importantly, a tech nerd. That may or may not be the reason for the creation of this account.

In my professional life, I am a Cybersecurity Engineer for an automotive company. There, I manage Elastic deployments, supplemented with various scripts (Bash, Python, PowerShell), to provide information security by means of host and network monitoring, alerting, and automation.

Both companies that have employed me in the past 6-7 years have worked quite closely with Elastic. Because of this, I have a fairly close working relationship with my sales rep. So, when he heard that I was using Elastic to store and search through my notes for the Dungeons & Dragons campaign that I play every weekend, he put me in touch with some people. I will explain in-depth very soon!

Be sure to look out for my weekly updates regarding my Elastic/D&D project on Friday evenings or Saturday mornings and don't hesitate to reach out if you have questions!

Talk to y'all soon,
Joe
Still No Way to Remove Garbage Dev.to notifications?
Tags: meta, ugh
Published: 2023-08-22 22:20:28

---
title: Still No Way to Remove Garbage Dev.to notifications?
published: true
description: the bell is ALWAYS red
tags: meta,ugh
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-08-22 22:15 +0000
---

I don't understand how anyone can use dev.to and deal with the notification bell being filled with garbage _all the time_.

This is all I have set in my bell-related notifications:
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zvwnywcr2zbn3aq4z6x4.png)

And yet here we are, tons of garbage. And it's always been like this. Look how tiny the scrollbar is:


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/723stzbvluffbau9op02.png)
How Express.js detects if a middleware is an error or request one
Tags: express, node, backend, fullstack
Published: 2023-08-22 22:19:47

## Situation
Suppose we have this code:
```js
const express = require('express');
const app = express();

// usual code - app.METHOD, app.use, routers etc

// below: wont' be treated as error middleware
app.use((req, res, next) => {}); 


// below: will be treated as an error middleware
app.use((err, req, res, next) => {});
```
&nbsp;


## Question
How does Express.js know which one is an error middleware, given both `app.use` take a callback (function).
&nbsp;
&nbsp;


## Explanation
Well it's quite simple. _JS allows us to calculate the number of params in a function_ ([MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length)). Syntax example:
```js
const mySumFunction = (a, b) => { return a + b; };

console.log(mySumFunction.length); // 2
```

This was surprising for me since I thought callback (or functions in general) are black-boxes, we could just call them, and that was it. But no.
&nbsp;
&nbsp;


## Evidence
Coming back to the topic, Express internally does this `.length` to decide if the middleware is a "request" or an "error" one.

See (Express.js repo at GitHub): https://github.com/expressjs/express/blob/3531987844e533742f1159b0c3f1e07fad2e4597/lib/router/layer.js#L89
uhtred.dev Is out now! A business around a freelancer
Tags: news, nuxt, django, googlecloud
Published: 2023-08-22 22:07:48

After years, I finally decided to take some time (approximately 2 months) to develop my personal [website](https://uhtred.dev). It's finally finished (or a good part of it hahah) and available to the world!

I decided to set up a website that presents me as the **Product Developer** freelancer that I am, someone capable of putting together the ideal on-demand team for the realization of a specific product.

**In general, the website will serve to**:

- Present the [success cases](https://uhtred.dev/cases) that I developed with my team. The cases/portfolio I'm referring to here are not just mockups that lead to a client's website, but details of the project/challenge. Its origin, related people and companies, the problem detected, the solution presented and how we implement it.

- Share various [insights](https://uhtred.dev/insights) about **business**, **freelancing**, **programming**, **design**, **finance** and other topics that can bring people together. Insights will be written by me and partners. You can be one of those partners too, here's the invitation.

- Provide some [digital products](https://uhtred.dev/store) that can complement other entrepreneurs and freelancers.

There isn't much content yet, but we already have enough to get a sense of what I just described above, so I invite you to explore the [website](https://uhtred.dev) and share your impressions if you wish.

**Here are some technical details about the website**:

- Front-end developed with Nuxt.js 3.
- Back-end and Back-office developed with Python and Django (Django Admin is the best!!)
- Build, test and delivery automation with Gitlab CI and Google Cloud Build
- Every website is on Google Cloud, some featured products are: Cloud SQL, Cloud Run and Cloud Storage

That's it, stay tuned for the next achievements!
Day 810 : Application
Tags: hiphop, code, coding, lifelongdev
Published: 2023-08-22 22:06:58

_liner notes_:
- Professional : Not a bad day. Had a meeting with my manager and we demoed the application I've been working on. It worked! There were a couple of other extra "icing on the cake" type of things I wanted to add. Learned a couple of new things. Cleaned up the code some. Did some refactoring. I just need to write up the ReadMe and get it posted to GitHub.

- Personal : Went through some tracks for the radio show. Spent most of the night working on my demo application for work. Pretty much it. The 360 videos were still uploading!

![View from inside an ice cave looking out at a star-filled night sky in Baden, Switzerland](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yhe0uo0k91dzjdce922q.jpg)

Going to write up this ReadMe for my demo application, push to GitHub, and close out a bunch of tabs I have open in my browser windows while researching. The videos finally uploaded to YouTube, but still going to the storage site. I was able to make a playlist and a clip of the videos and post to social media. The videos are up at https://ourshow.in/moc360 I've been looking at a lot of code so I may just go through some tracks and then end the night watching some anime. Not sure if I'll do anything with my side project.

Have a great night!

peace piece
Dwane / conshus
https://dwane.io / https://HIPHOPandCODE.com
{% youtube 9_3li9ruEVM %}