id int64 5 1.93M | title stringlengths 0 128 | description stringlengths 0 25.5k | collection_id int64 0 28.1k | published_timestamp timestamp[s] | canonical_url stringlengths 14 581 | tag_list stringlengths 0 120 | body_markdown stringlengths 0 716k | user_username stringlengths 2 30 |
|---|---|---|---|---|---|---|---|---|
1,873,705 | Using Keycloak in .NET Aspire projects | TL;DR You can use Keycloak.AuthServices.Templates to add Keycloak support for .NET Aspire... | 0 | 2024-06-05T10:52:01 | https://nikiforovall.github.io/dotnet/keycloak/2024/06/02/aspire-support-for-keycloak.html | dotnet, keycloak, aspire, aspnetcore | ---
title: Using Keycloak in .NET Aspire projects
published: true
date: 2024-06-02 00:00:00 UTC
tags: dotnet, keycloak, aspire, aspnetcore
canonical_url: https://nikiforovall.github.io/dotnet/keycloak/2024/06/02/aspire-support-for-keycloak.html
---
## TL;DR
You can use [Keycloak.AuthServices.Templates](https://www.nuget.org/packages/Keycloak.AuthServices.Templates/) to add Keycloak support for .NET Aspire projects. See the docs for more details - [Keycloak.AuthServices/Aspire Support](https://nikiforovall.github.io/keycloak-authorization-services-dotnet/devex/aspire.html).
Source code: [https://github.com/NikiforovAll/keycloak-aspire-starter-template](https://github.com/NikiforovAll/keycloak-aspire-starter-template)
- [TL;DR](#tldr)
- [Introduction](#introduction)
- [Scaffold a solution](#scaffold-a-solution)
- [Run it](#run-it)
- [Code Explained](#code-explained)
- [Conclusion](#conclusion)
- [References](#references)
## Introduction
From the official [docs](https://learn.microsoft.com/en-us/dotnet/aspire/get-started/aspire-overview):
> .NET Aspire is designed to improve the experience of building .NET cloud-native apps. It provides a consistent, opinionated set of tools and patterns that help you build and run distributed apps.
Personally, I’m a big fan of Aspire because it enables great developer experience and productivity. I recommend trying it on your own 🚀
This article will show you how to get started with Keycloak and Aspire. It is based on [Keycloak.AuthServices.Templates](https://www.nuget.org/packages/Keycloak.AuthServices.Templates) template. Templates make it really easy to get started.
💡Here is a basic example of how the integration looks like:
```csharp
var builder = DistributedApplication.CreateBuilder(args);
var keycloak = builder
.AddKeycloakContainer("keycloak")
.WithDataVolume();
var realm = keycloak.AddRealm("Test");
builder.AddProject<Projects.Api>("api")
.WithReference(realm);
builder.Build().Run();
```
### Scaffold a solution
Install a templates pack:
```bash
❯ dotnet new install Keycloak.AuthServices.Templates
# The following template packages will be installed:
# Keycloak.AuthServices.Templates::2.5.0
# Success: Keycloak.AuthServices.Templates::2.5.0 installed the following templates:
# Template Name Short Name Language Tags
# ----------------------- ----------------------- -------- -------------------------------------
# Keycloak Aspire Starter keycloak-aspire-starter [C#] Common/.NET Aspire/Cloud/API/Keycloak
# Keycloak WebApi keycloak-webapi [C#] Common/API/Keycloak
❯ dotnet new keycloak-aspire-starter -o $dev/keycloak-aspire-starter-template
# The template "Keycloak Aspire Starter" was created successfully.
```
Here is what was generated:
```bash
❯ tre
.
├── .gitignore
├── Api
│ ├── Api.csproj
│ ├── Extensions.OpenApi.cs
│ ├── Program.cs
│ ├── Properties
│ │ └── launchSettings.json
│ ├── appsettings.Development.json
│ └── appsettings.json
├── AppHost
│ ├── AppHost.csproj
│ ├── KeycloakConfiguration
│ │ ├── Test-realm.json
│ │ └── Test-users-0.json
│ ├── Program.cs
│ ├── Properties
│ │ └── launchSettings.json
│ ├── appsettings.Development.json
│ └── appsettings.json
├── Directory.Build.props
├── Directory.Packages.props
├── README.md
├── ServiceDefaults
│ ├── Extensions.cs
│ └── ServiceDefaults.csproj
├── global.json
└── keycloak-aspire-starter-template.sln
```
### Run it
```bash
❯ dotnet run --project ./AppHost/
# Building...
# info: Aspire.Hosting.DistributedApplication[0]
# Aspire version: 8.0.1+a6e341ebbf956bbcec0dda304109815fcbae70c9
# info: Aspire.Hosting.DistributedApplication[0]
# Distributed application starting.
# info: Aspire.Hosting.DistributedApplication[0]
# Application host directory is: C:\Users\Oleksii_Nikiforov\dev\keycloak-aspire-starter-template\AppHost
# info: Aspire.Hosting.DistributedApplication[0]
# Now listening on: http://localhost:15056
# info: Aspire.Hosting.DistributedApplication[0]
# Distributed application started. Press Ctrl+C to shut down.
```
Here are resources from Aspire Dashboard:
<center>
<img src="https://nikiforovall.github.io/assets/keycloak-aspire/dashboard-resources.png" style="margin: 15px;">
</center>
As you can see, there is a `quay.io/keycloak/keycloak:24.0.3` container running. It is available on your local machine: [http://localhost:8080/](http://localhost:8080/). Use `admin:admin` credentials.
The template project was generated with exemplary import files. It imports _Test_ realm, adds _workspaces-client_, and seeds test users:
<center>
<img src="https://nikiforovall.github.io/assets/keycloak-aspire/test-realm.png" style="margin: 15px;">
</center>
Now, we can open Swagger UI and retrieve an access token. Note, imported realm is configured to support [Implicit Flow](https://oauth.net/2/grant-types/implicit/). We can use it during the development process as demonstrated below.
<center>
<img src="https://nikiforovall.github.io/assets/keycloak-aspire/auth-swagger-ui.png" width="100%" style="margin: 15px;">
</center>
To invoke the API you can use Swagger UI or other HTTP tool of your choice. Here is an example of how to use `cURL`:
```bash
curl -X 'GET' \
'https://localhost:51492/hello' \
-H 'accept: text/plain' \
-H 'Authorization: Bearer <AUTH_TOKEN>'
# Hello World!
```
## Code Explained
Basically, to setup Keycloak installation with Aspire we need to setup two things:
1. Add Keycloak Resource to Aspire `AppHost`.
2. Configure Web API to target Keycloak installation
Here is how to add Keycloak as resource to Aspire:
```csharp
// AppHost/Program.cs
var builder = DistributedApplication.CreateBuilder(args);
var keycloak = builder
.AddKeycloakContainer("keycloak")
.WithDataVolume()
.WithImport("./KeycloakConfiguration/Test-realm.json")
.WithImport("./KeycloakConfiguration/Test-users-0.json");
var realm = keycloak.AddRealm("Test");
builder.AddProject<Projects.Api>("api").WithReference(keycloak).WithReference(realm);
builder.Build().Run();
```
The code above does the following:
1. Starts a Keycloak Instance
2. Imports realm and test users
3. Reference to Keycloak adds Keycloak to service discovery
4. Reference to Realm adds _Keycloak\_\_Realm_ and _Keycloak\_\_AuthServerUrl_ environment variables.
And here is how to configure `Api` to integrated with Keycloak and use _workspaces-client_:
```csharp
// Api/Program.cs
using Api;
using Keycloak.AuthServices.Authentication;
var builder = WebApplication.CreateBuilder(args);
var services = builder.Services;
var configuration = builder.Configuration;
builder.AddServiceDefaults();
services.AddApplicationOpenApi(configuration);
services.AddKeycloakWebApiAuthentication(
configuration,
options =>
{
options.Audience = "workspaces-client";
options.RequireHttpsMetadata = false;
}
);
services.AddAuthorization();
var app = builder.Build();
app.UseHttpsRedirection();
app.UseApplicationOpenApi();
app.UseAuthentication();
app.UseAuthorization();
app.MapGet("/hello", () => "Hello World!").RequireAuthorization();
app.Run();
```
## Conclusion
The integration of Keycloak with .NET Aspire projects provides a first class support for building distributed, cloud native systems. By leveraging the `Keycloak.AuthServices.Templates` template, developers can easily scaffold a solution and configure their APIs to work with Keycloak.
* * *
🙌 `Keycloak.AuthServices.Templates` is under development. Please, feel free to submit PRs. [](https://github.com/nikiforovall/keycloak-authorization-services-dotnet) 🙌
## References
- [https://github.com/NikiforovAll/keycloak-authorization-services-dotnet](https://github.com/NikiforovAll/keycloak-authorization-services-dotnet)
- [https://nikiforovall.github.io/keycloak-authorization-services-dotnet/devex/aspire.html](https://nikiforovall.github.io/keycloak-authorization-services-dotnet/devex/aspire.html)
- [https://learn.microsoft.com/en-us/dotnet/aspire/](https://learn.microsoft.com/en-us/dotnet/aspire/) | nikiforovall |
1,863,232 | Speeding up installation of AIO (Azure IoT Operations) deployment using a script | If you're eager to learn more about AIO (Azure IoT Operations), which is currently in private... | 0 | 2024-06-01T23:57:05 | https://dev.to/danuw/re-installing-aio-azure-iot-operations-5f73 | aio, tutorial | If you're eager to learn more about AIO (Azure IoT Operations), which is currently in private preview, it's crucial to start with a fresh install to experiment quickly and efficiently. In this post, I will guide you through the steps to reinstall your cluster using a script, ensuring a smooth learning experience. Let's get started!
For now, the assumption is that you are using [fresh codespace using those steps](https://learn.microsoft.com/en-us/azure/iot-operations/get-started/quickstart-deploy#connect-a-kubernetes-cluster-to-azure-arc). Updated script for physical machines with Ubuntu server coming soon...
## Setup the cluster again and deploy the AIO extension
> Note: if your are looking at a [new version of AIO](https://github.com/Azure/azure-iot-operations/releases), the script may need adapting - this has been tested with AIO v0.5-preview at the time of writing
### 1. Set up your variables
#### 1.a RESOURCE_GROUP
When you created your Codespace, you had to provide some variable values such as the resource group, so double check that the resource group variable is what you expect with `echo $RESOURCE_GROUP`, and otherwise set it using (update value as needed):
```bash
export RESOURCE_GROUP=aio-codespace-rg
```
#### 1.b IOT OPS USER_EMAIL
To ensure your user can access the AIO UI, specify your IoT Ops user email with the following command, replacing <your-email> with your actual email address:
```bash
export USER_EMAIL=<your-email>
```
> Note: Remember that user needs to be a member of the tenant such as iotops@YOUTENANT.onmicrosoft.com
> If you do not have one, use `export USER_EMAIL=$(az ad user create --display-name 'IoT Ops User' --password <PASSOWRD> --user-principal-name iotop@<TENANTNAME>.onmicrosoft.com --force-change-password-next-sign-in false -o tsv --query userPrincipalName)`
### 1.c Other Variables (optional)
Consider double checking other environment variables such as the $CLUSTER_NAME to suit your preferences.
### 2. Login
Ensure you are signed into your Azure Account by running the following command in your terminal, then follow the instructions in your browser:
```bash
az login --use-device-code
```
### 3. Run your setup script
Create a file named setup.sh in your Codespace and copy the content from [this gist](https://gist.github.com/danuw/37c931341d5cde145564a5bfe05cc4c7/2fb3c5452d273a884da1dd8a28a7100bdfd1a656) into it.
Once you have updated your variables and logged into Azure, you are ready to run the script with the following command:
```bash
. ./setup.sh
```
> Note: Currently tested on Codespace, but will soon update with script for Ubuntu server including Az CLI install and other pre-requisites for re-install
### 4. Manual Validation
Based on experience, if your Codespace setup remains unchanged (same number of cores, etc.), you can expect this whole process to take approximately 25 minutes.
After the process completes, navigate to [IoT Operations Portal](https://iotoperations.azure.com) and sign in with your member user account. You should see your cluster listed as connected.
## Next?
Thank you for reading this far. I hope this script helps you experiment faster with AIO. In the future, I plan to:
- Expand the script with new steps: As AIO evolves and more APIs become available, additional processes can be automated. You may also consider improving the script as you explore or revisit the latest features, in which case don't forget to let me know in the gist's comments.
- Cover more scenarios, such as creating assets using CLI.
References:
- https://github.com/Azure/azure-iot-ops-cli-extension
- https://learn.microsoft.com/en-us/cli/azure/iot/ops?view=azure-cli-latest
- https://learn.microsoft.com/en-us/azure/azure-arc/kubernetes/custom-locations
- https://learn.microsoft.com/en-us/azure/iot-operations/get-started/quickstart-deploy
- https://learn.microsoft.com/en-us/azure/iot-operations/manage-devices-assets/howto-manage-assets-remotely?tabs=cli | danuw |
1,873,353 | Beachcomber: A Legacy of Family Values and Global Excellence in Hot Tub Manufacturing | Beachcomber is committed to strong family values across its entire organization, advocating for... | 0 | 2024-06-01T23:52:21 | https://dev.to/beachcomber1/beachcomber-a-legacy-of-family-values-and-global-excellence-in-hot-tub-manufacturing-2hjj | Beachcomber is committed to strong family values across its entire organization, advocating for health and happiness for everyone. Much like Porsche©, Beachcomber aims to grow alongside its staff and customers, treating each one like family. The company's pride lies not only in its high-quality handcrafted hot tubs but also in the enduring family bonds and fellowship nurtured over the decades.
As a family-owned and operated multi-generational business, Beachcomber Hot Tubs is dedicated to supporting families for generations to come. This legacy is illustrated by the presence of three generations at the factory, with founder Keith, his son Blake, and grandson Frankie working together to continue the tradition of excellence.
Beachcomber Hot Tubs has built a global reputation for its zero-defects approach and rigorous quality control in hot tub manufacturing. From Norway to Argentina and Ireland to Japan, the company's dream has evolved into a trusted global brand, represented in over 40 countries worldwide.
The company maintains a full-time specialized workforce focused on producing high-quality hot tubs and providing dedicated customer care. Beachcomber's brand is available through an omni-channel marketplace, which includes an international network of factory-trained distributors and dealerships, factory outlets that test retail experience concepts, omni-channel merchants whose values align with the company's, and a user-friendly online presence that ensures seamless pricing across all platforms.
[](https://www.beachcomberhottubs.com/) | beachcomber1 | |
1,850,811 | 🪟Ferramentas para produtividade para dev no Sistema operacional Windows 11 | Introdução Sistema operacional 🪟 Windows 11 O Windows 11, com sua interface moderna e... | 0 | 2024-06-01T23:51:22 | https://dev.to/neiesc/dicas-e-truques-ferramentas-para-produtividade-para-dev-no-sistema-operacional-windows-11-1627 | braziliandevs, windows11, tools, productivity | ## Introdução
Sistema operacional 🪟 [Windows 11](https://www.microsoft.com/en-us/windows/windows-11)
O Windows 11, com sua interface moderna e recursos aprimorados, tem se tornado cada vez mais popular entre desenvolvedores. Neste artigo, exploraremos como personalizar e otimizar o Windows 11 para criar um ambiente de desenvolvimento altamente produtivo e eficiente. Apresentaremos uma seleção cuidadosa de ferramentas e configurações, fruto de mais de uma década de experiência na criação e refinamento de dotfiles personalizados.
Com o objetivo de aprimorar o fluxo de trabalho e impulsionar a produtividade, vamos mergulhar em um conjunto abrangente de aplicativos, extensões e personalizações. Desde gerenciadores de pacotes versáteis e soluções robustas de segurança até terminais poderosos e utilitários indispensáveis, exploraremos cada componente essencial para transformar o Windows 11 em uma verdadeira potência para desenvolvimento.
Prepare-se para descobrir como aproveitar ao máximo o Windows 11, otimizando seu sistema operacional para atender às suas necessidades específicas de desenvolvimento e desbloquear todo o seu potencial criativo.
[meu dotfiles](https://github.com/neiesc/dotfiles) com mais de uma decada de criação
.
## Ferramentas
1. Gerenciador de pacote 📦 ([WingetUI](https://www.marticliment.com/wingetui)) Winget, Scoop, Chocolatey, Pip, Npm, .NET Tool e PowerShell Gallery.
1. Gerenciador de senhas 🔑 ([Bitwarden](https://bitwarden.com)) Uso gerenciadores de senha desde 2011 ~ 2012 sendo essencial hoje em dia já que cada vez mais temos bases expostas:
1. [Ambie White Noise](https://ambieapp.com) utilizo como com a técnica pomodoro e quando preciso colocar alguns sons de fundo ou fazer meditações.
1. [Windows Terminal](https://github.com/microsoft/terminal), já testei muitos terminais tanto no Windows o melhor sem dúvidas é o Windows Terminal.
1. [DevToys](https://devtoys.app) o canivete suíço para desenvolvedores. mais de 28 ferramentas, incluindo:
- Json to Yaml and Yaml to Json converter
- Base64 Text & Image converter
- JWT encoder and decoder
- Text comparer
- Hash generator
- and more are coming! See the whole list here.
1. [Microsoft PowerToys](https://github.com/microsoft/PowerToys)
1. [Win-Debloat-Tools](https://github.com/LeDragoX/Win-Debloat-Tools)
1. [Visual Studio Code](https://code.visualstudio.com)
1. [Nushell](https://www.nushell.sh)
1. [proto](https://moonrepo.dev/proto)
1. [1.1.1.1](https://one.one.one.one/)
1. [GitKraken](https://www.gitkraken.com/)
## Conclusão
Em suma, o Windows 11, equipado com as ferramentas certas e personalizadas de acordo com as suas preferências, se transforma em um ambiente de desenvolvimento poderoso e eficiente. A combinação de gerenciadores de pacotes versáteis, soluções de segurança robustas, terminais personalizáveis e utilitários indispensáveis, como os mencionados neste artigo, capacita os desenvolvedores a maximizar sua produtividade e criatividade.
Ao adotar essas ferramentas e personalizações, você estará aproveitando o melhor do Windows 11 para criar um espaço de trabalho otimizado e adaptado às suas necessidades específicas. Com um ambiente de desenvolvimento sob medida, você estará pronto para enfrentar qualquer desafio de codificação com confiança e eficiência. Experimente essas sugestões e descubra como o Windows 11 pode impulsionar seu fluxo de trabalho e elevar seus projetos a um novo patamar.
## Referencias
- https://unsplash.com/photos/person-using-windows-11-computer-on-lap-AigsWJmvoEo
- https://dev.to/nickytonline/tools-that-keep-me-productive-1no5
- https://www.akitaonrails.com/2022/02/15/akitando-114-o-melhor-setup-dev-com-arch-e-wsl2 | neiesc |
1,873,352 | Adapt Kotlin 2.0 in Android applications | Read this post in Spanish here. Recently, version 2.0 of Kotlin has been released, and with it,... | 0 | 2024-06-01T23:43:07 | https://dev.to/marlonlom/adapt-kotlin-20-in-android-applications-3cmk | kotlin, android, jetpackcompose, k2 | > [Read this post in Spanish here.](https://dev.to/marlonlom/adaptar-kotlin-20-en-aplicaciones-android-1kfa)
Recently, version 2.0 of Kotlin has been released, and with it, several adjustments to Android projects to adapt or implement code with this new version of the programming language officially supported by Google for Android mobile development (Multiplatform, according to the latest versions of the Google I/O event).
In this short article, I explain my experience migrating from version `1.9.23` to version `2.0.0`; This, due to the novelties that the use of this new version covers in projects that use Kotlin as a programming language, and also the possible difficulty for many of us developers to apply migrations from versions of Kotlin much lower than `1.9.0 `.
## About the K2 compiler
The K2 compiler is a complete reimplementation of the original Kotlin compiler, designed to offer significant improvements in Android application development. Introduced in Kotlin 2.0, K2 provides several advantages, among which are: faster compilation speed, performance improvements, and improved cross-platform support; These advantages applied to Android projects allow a reduction in the size of the applications by generating more compact code, as well as the generation of native code which implies greater performance in mobile applications.
### How to test K2 compiler on Android?
It is worth mentioning that this section covers the configuration aspect from the point of view of Android projects. I will not mention details of KMP, although several of the details indicated are easy to assimilate if one already has experience in cross-platform projects using Kotlin.
#### 1. A new build directory
Kotlin 2.0 introduces a new build output directory: `.kotlin`. you must add it to the `.gitignore` file so that its contents do not appear in commits:
```
#.gitignore
# Kotlin 2.0
.kotlin/
```
#### 2. Apply new version of kotlin
Now we go to the gradle/libs.versions.toml file, in this section, it is assumed that Version Catalogs are being used to control the dependencies of the mobile application (versions, plugins, etc.), The reference to the Kotlin version is located, and it is changed to version 2.0.0. So:
```
# gradle/libs.versions.toml
[versions]
agp="8.4.1"
kotlin="2.0.0"
ksp="2.0.0-1.0.21"
```
Regarding compatibility, the versions of the Kotlin symbol processor (KSP) libraries and the gradle plugin for Android (AGP, acronym used for reference) must also be updated. The previous snippet indicates the versions for review.
At the library level, the following Kotlin libraries are also updated:
```
# gradle/libs.versions.toml
[libraries]
kotlin-gradle-plugin = "org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.0"
kotlin-serialization-plugin = "org.jetbrains.kotlin:kotlin-serialization:2.0.0"
```
> Note: there are libraries that, at the time of writing this article, did not present problems in terms of changing versions, such as `kotlin-coroutines`, `kotlin-serialization`, `kotlin-serialization-json`.
At the plugin level, the Kotlin libraries are also updated below, taking into account the version reference already indicated previously:
```
# gradle/libs.versions.toml
[plugins]
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
```
With this done, run the command `gradle clean build` or from Android Studio, build the project.
#### 3. Update the Compose compiler
Another important aspect regarding the configuration of Android projects, especially using Jetpack Compose, is related to the Compose compiler for Kotlin, which is a configuration that allows the transformation of functions annotated as `@Composable` in order to apply optimizations In the compilation of these functions, now, the way of defining the version of the compose compiler has presented a big change, which is described below.
Previously, the version of the compose compiler had to be placed inside the build.gradle file of the gradle project module that has the Android implementations and that also contains the Jetpack Compose implementations.
```
/* build.gradle.kts */
…
composeOptions {
kotlinCompilerExtensionVersion="1.5.3"
}
…
```
And if you use Version Catalogs, the version would be indicated as follows:
```
# gradle/libs.versions.toml
[versions]
compose-compiler = “1.5.3”
…
```
```
/* build.gradle.kts */
…
composeOptions {
kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
}
…
```
This initiative was good at the time, but it has some maintenance problems, since it is required to be compatible with the current version of Kotlin. It is different from the Compose version and the IDE did not propose to improve it. Every time you update your Kotlin version, you have to Google the Jetpack Compose documentation for the compatible version of the Compose compiler. Kotlin 2.0 solves this problem.
Now, the inclusion of a new gradle plugin is applied to the `gradle/libs.versions.toml` file, which is responsible for managing the more organized version of the compose compiler and linked to the Kotlin version.
```
# gradle/libs.versions.toml
[plugins]
…
kotlin-compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
```
After this action, the `build.gradle.kts` file of the Android module that has the Jetpack Compose capabilities is modified, removing the `composeOptions configuration. kotlinCompilerExtensionVersion ` and adding the reference to the `kotlin-compose-compiler` plugin in the `plugins { .. }` section.
```
/* build.gradle.kts */
…
plugins {
…
alias(libs.plugins.compose.compiler)
}
…
```
With this done, run the `gradle clean build` command or from Android Studio, build the project or synchronize.
And that's it! This plugin will configure the Compose compiler version based on the current Kotlin version.
## Conclusions
Overall, the K2 compiler represents a significant step forward for Android app development with Kotlin. Improvements in speed, performance, and extensibility make it a valuable tool for Android developers.
Now that the use of Kotlin 2.0.0 is becoming standard, now is a good time to update our Android applications so that they support more of the technology that goes and evolves in terms of Kotlin, KMP, Jetpack Compose, and the other technologies that Google and app developers and mobile libraries are adapting for more modern mobile apps with better features.
I hope you find this informative and useful and that at some point you can follow these steps in your Android applications, in order to apply a good migration to Kotlin 2.0.0.
Thanks for reading, happy coding! 😊
| marlonlom |
1,873,351 | Procuro Devs Pleno e Senior | Hey, galera! Procuro Devs Pleno e Senior que estão acabando projeto ou em busca de um novo desafio... | 0 | 2024-06-01T23:41:28 | https://dev.to/fernanda_picazio/procuro-devs-pleno-e-senior-3o97 | Hey, galera! Procuro Devs Pleno e Senior que estão acabando projeto ou em busca de um novo desafio para assessorar como Headhunter nível Brasil (sou de SP o maior pólo no país em vagas de Tecnologia).
Para saber mais sobre o meu trabalho, me chama no meu wapp 11 99369-0258.
Bjs, Fe ❤️ | fernanda_picazio | |
1,873,350 | Kelebihan dan Harga Pagar Panel Beton | Kelebihan Pagar Panel Beton Pagar panel beton semakin populer dalam berbagai aplikasi konstruksi... | 0 | 2024-06-01T23:41:22 | https://dev.to/sodiumxyz/kelebihan-dan-harga-pagar-panel-beton-5gi2 | Kelebihan Pagar Panel Beton
Pagar panel beton semakin populer dalam berbagai aplikasi konstruksi karena sejumlah kelebihan yang ditawarkannya. Berikut beberapa kelebihan utama dari pagar panel beton:
1. Kekuatan dan Ketahanan
Pagar panel beton memiliki kekuatan struktural yang tinggi dan tahan terhadap tekanan serta cuaca ekstrem. Material beton ini juga tahan terhadap korosi, rayap, dan kebakaran, menjadikannya pilihan yang tahan lama untuk berbagai kondisi lingkungan.
2. Instalasi Cepat dan Mudah
Proses instalasi pagar panel beton lebih cepat dibandingkan dengan pagar konvensional. Panel pracetak ini dirancang untuk pemasangan yang mudah dan cepat di lokasi proyek, sehingga menghemat waktu dan biaya.
3. Perawatan Rendah
Beton tidak memerlukan perawatan rutin seperti pengecatan ulang atau perlindungan dari hama, yang menghemat biaya perawatan dalam jangka panjang. Inspeksi berkala cukup untuk memastikan tidak ada kerusakan struktural.
4. Estetika
Pagar panel beton tersedia dalam berbagai desain dan tekstur yang dapat disesuaikan dengan kebutuhan estetika proyek. Ini memberikan tampilan yang rapi dan profesional untuk berbagai aplikasi, baik komersial, industri, maupun perumahan.
5. Keamanan dan Privasi
Pagar beton menawarkan keamanan yang baik karena sulit untuk ditembus. Selain itu, memberikan privasi yang optimal karena struktur betonnya yang solid dan tinggi.
[Harga Pagar Panel Beton](https://amertaprima.co.id/produk-precast/pagar-panel-beton/)
Harga pagar panel beton dapat bervariasi tergantung pada beberapa faktor, seperti ukuran, ketebalan, desain, dan lokasi pemasangan. Berikut beberapa faktor yang mempengaruhi harga pagar panel beton:
1. Ukuran dan Ketebalan
Pagar panel beton tersedia dalam berbagai ukuran dan ketebalan. Pagar yang lebih besar dan tebal biasanya lebih mahal karena membutuhkan lebih banyak bahan dan tenaga kerja untuk produksi dan pemasangannya.
2. Desain dan Finishing
Desain dan finishing khusus dapat meningkatkan biaya pagar panel beton. Misalnya, pagar dengan tekstur atau pola dekoratif biasanya lebih mahal dibandingkan dengan yang polos.
3. Jumlah yang Dibutuhkan
Pembelian dalam jumlah besar sering kali mendapatkan harga yang lebih baik per unit dibandingkan dengan pembelian dalam jumlah kecil.
4. Lokasi Pemasangan
Biaya transportasi dan pemasangan dapat bervariasi tergantung pada lokasi proyek. Pemasangan di area yang sulit dijangkau atau membutuhkan peralatan khusus dapat meningkatkan biaya total.
5. Produsen atau Distributor
Harga juga dapat bervariasi antara produsen atau distributor. Penting untuk memilih produsen atau distributor yang terpercaya untuk mendapatkan produk berkualitas dengan harga yang kompetitif.
Kesimpulan
Pagar panel beton menawarkan banyak kelebihan seperti kekuatan, ketahanan, instalasi cepat, perawatan rendah, estetika, serta keamanan dan privasi. Harga pagar panel beton dipengaruhi oleh ukuran, ketebalan, desain, jumlah, lokasi pemasangan, dan produsen atau distributor. Untuk mendapatkan pagar panel beton berkualitas dengan harga yang kompetitif, pilihlah produsen atau distributor yang terpercaya dan berpengalaman seperti CV Amerta Prima.
Dengan reputasi yang solid dan komitmen terhadap kualitas, CV Amerta Prima menawarkan berbagai pilihan pagar panel beton yang sesuai dengan kebutuhan proyek Anda. Untuk informasi lebih lanjut dan penawaran harga, kunjungi situs web resmi CV Amerta Prima. | sodiumxyz | |
1,873,346 | It is so great when you try to find the bug in your code and it's just... a typo. Frustrating, yet great! | A post by BrendonMedeiros | 0 | 2024-06-01T23:25:33 | https://dev.to/punkdev/it-is-so-great-when-you-try-to-find-the-bug-in-your-code-and-its-just-a-typo-frustrating-yet-great-4kbd | punkdev | ||
1,873,342 | Is Temporal still temporal? | Temporal is the new JavaScript standard for date manipulations. It has a long, difficult journey that... | 0 | 2024-06-01T23:13:23 | https://dev.to/artalar/is-temporal-still-temporal-19f0 | webdev, javascript, temporal | [Temporal](https://tc39.es/proposal-temporal/docs/) is the new JavaScript standard for date manipulations. It has a long, difficult journey that I want to share with you. Is it ready for production or not? Let's find out!
## Introduction
On [May 13, 2017, the first commit](https://github.com/tc39/proposal-temporal/commit/8a171d1661babda716251250fbdb4dd39f2dd1c2) of the Temporal Proposal was made, heralding a new API for date manipulation, inspired by popular libraries like moment.js and luxon.
Temporal aims to correct many of the pain points associated with the existing `Date` object in JavaScript, providing a better, more reliable framework for handling dates and times. Over the years, Temporal has evolved significantly, incorporating numerous features and improvements.
## Key Differences from Date
Temporal introduces several significant improvements over the traditional `Date` object:
1. **Correct Time Zone Handling**: Temporal is designed with thoughtful time zone management, allowing developers to handle cross-time zone scenarios seamlessly.
2. **Immutable API**: The API is immutable, ensuring that date objects aren't accidentally modified and every operation returns a new object.
3. **Duration Handling**: Temporal includes robust support for intervals through the `Duration` object, making it easier to work with time durations.
Here's an example to demonstrate the ease of use:
```js
const start = Temporal.PlainDateTime.from('2024-01-01T10:00');
const duration = Temporal.Duration.from({ hours: 3, minutes: 15 });
const end = start.add(duration);
console.log(start.toString()); // 2024-01-01T10:00
console.log(end.toString()); // 2024-01-01T13:15
console.log(duration.toString()); // PT3H15M
```
And another example:
```js
const date1 = Temporal.PlainDate.from('2024-01-01');
const date2 = Temporal.PlainDate.from('2024-12-31');
const difference = date1.until(date2);
console.log(difference.toString()); // P11M30D (11 months and 30 days)
```
## Comprehensive Entity Model
Temporal's design incorporates a comprehensive model for date and time entities:
- **PlainDate**: Represents a date without a time zone.
- **PlainTime**: Represents a time of day without a date or time zone.
- **PlainDateTime**: Represents a combination of date and time without a time zone.
- **ZonedDateTime**: Represents a date and time in a specific time zone.
- **Duration**: Represents a time interval.
- **Instant**: Represents an exact moment in time.
You can read more about the [schematic of key entities here](https://tc39.es/proposal-temporal/docs/#object-relationship).
## Active Development and Polyfill
In 2020, there was [intensive work on the polyfill](https://github.com/js-temporal/temporal-polyfill/graphs/code-frequency). Igalia played a crucial role, investing significant effort into the development process. They wrote extensive tests, ensured type safety, and added numerous runtime assertions—adhering to best practices meticulously.
I personally used this polyfill for a year while developing a Node.js project and was extremely satisfied. I didn't encounter any bugs and even [submitted a PR to improve typings](https://github.com/tc39/proposal-temporal/pull/1445). It's gratifying to make even a small contribution to such a major project.
## Why Temporal?
By 2021, I considered the Temporal proposal and its polyfill the most well-thought-out tool for date manipulation, and I still hold this view. However, the polyfill [weighs 200 kB (50 kB gzip)](https://bundlejs.com/?q=@js-temporal/polyfill), making it somewhat heavy for front-end use. Nonetheless, it's worth noting that once Temporal is natively supported in browsers, you can simply remove the polyfill without altering your code—a luxury not available with other date libraries from NPM.
However, I couldn't afford to drag such a heavy library into every web application, and I forgot about Temporal for a while. Three years have passed since I used a well-crafted polyfill, so why hasn't it been shipped to all browsers yet?
## Roadblocks to Becoming a Standard
A key feature of the new API is sophisticated time zone management. However, this couldn't be implemented fully due to inadequacies in the existing time zone standard. [Ujjwal](https://github.com/ryzokuken), an Igalia employee and the primary developer of Temporal, proposed [extending the internet's date-time standard](https://ryzokuken.dev/draft-ryzokuken-datetime-extended/documents/rfc-3339.html) to allow for additional information. For instance, while Hawaiian law mandates a single standard time, locals often follow a different time zone. This issue isn't theoretical; it was an actual problem for my friend, a developer. The proposed extension permits specifying not just the time zone but also the [specific "calendar"](https://tc39.es/proposal-temporal/docs/calendar-review.html), accommodating such nuances.
The proposal's acceptance was a significant milestone. As of [October 23, 2023](https://mailarchive.ietf.org/arch/msg/ietf-announce/g_JdmxVWPKhV_GYYcSKVUk5czjE/), the proposal was approved!
### Platform Support
It's hard to predict when Temporal will become a standard and be available in all browsers, but there's progress. For instance, the [V8 implementation of Temporal now occupies over 2.6% of the binary](https://github.com/tc39/proposal-temporal/issues/2786), and you can [already use it in Deno](https://deno.com/blog/v1.40).
## Current Status and Future Outlook
Development on Temporal continues, with seemingly no remaining major blockers. You can track the current status here: [GitHub Issues - Proposal Temporal](https://github.com/tc39/proposal-temporal/issues/2628).
For example, recently (May 2024), [a method was removed](https://github.com/tc39/proposal-temporal/commit/d83084aab3cdf64f3cb761ad08334c9907c72e7d) - an intriguing change for a proposal on its way to becoming a standard. Does this mean Temporal is not ready yet? No, I think for a long time we can imagine Temporal as a mature date library that evolves and develops smoothly, just like any other NPM library.
So, what's better — a library with specific APIs without feature, or Temporal - a well-done, comprehensive date framework with ongoing improvements?
## Polyfill
The only complexity with Temporal is the size of the polyfill. However, an alternative polyfill has been in development for some time now — [temporal-polyfill](https://github.com/fullcalendar/temporal-polyfill) by [FullCalendar](https://fullcalendar.io/). Its size is much more appealing: 60.7 kB to 21.7 kB (gzip). And I plan to use it in my next project! How about you? | artalar |
1,873,343 | Enhance Your Deployments with Pod Topology Spread Constraints: K8s 1.30 | Pod Topology Spread Constraints in Kubernetes help us spread Pods evenly across different parts of a... | 0 | 2024-06-01T23:09:15 | https://dev.to/cloudy05/enhance-your-deployments-with-pod-topology-spread-constraints-k8s-130-14bp | kubernetes, cloudcomputing, cloudnative, aws | Pod Topology Spread Constraints in Kubernetes help us spread Pods evenly across different parts of a cluster, such as nodes or zones. This is great for keeping our applications resilient and available. This feature makes sure to avoid clustering too many Pods in one spot, which could lead to a single point of failure.
**Key Parameters:-**
1. Topology Key:- This is a label key that defines where your Pods can be placed in the cluster. Available topology keys
⇒ kubernetes.io/hostname → This key spreads Pods across different nodes within the cluster.
⇒ topology.kubernetes.io/zone → This key spreads Pods across different availability zones.
⇒ topology.kubernetes.io/region → This key spreads Pods across different regions.
2. MaxSkew:- Maximum allowed difference in the number of Pods between the most and least populated groups defined by your Topology Key.
3. WhenUnsatisfiable:- This is what Kubernetes does when it can't meet your specified Pod spread criteria.
⇒ DoNotSchedule → Prevents scheduling if the constraint is violated.
⇒ ScheduleAnyway → Allows scheduling but logs a warning.
4. LabelSelector:- Standard Kubernetes label selector to filter which Pods are considered for the constraint.
5. minDomain:- Ensures that pods are spread across at least ‘n’ different zones. This is an optional field which can only be used when using the
#### Basic YAML configuration
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: new-app
spec:
replicas: 5
selector:
matchLabels:
app: new-app
template:
metadata:
labels:
app: new-app
spec:
topologySpreadConstraints:
- maxSkew: 1
topologyKey: "topology.kubernetes.io/zone"
whenUnsatisfiable: "DoNotSchedule"
labelSelector:
matchLabels:
app: new-app
minDomains: 3
containers:
- name: new-app-container
image: new-app-image
```
#### Note -
Suppose we have three zones, and we are deploying Pods with a maxSkew of 1. The distribution might look like this:
• Zone A: 2 Pods
• Zone B: 2 Pods
• Zone C: 1 Pod
Here, we can see that the maximum difference in Pod counts between the zones is not more than 1. Therefore, any new Pods will be scheduled as long as this difference does not exceed 1. If the difference were greater than 1, the system would not schedule any additional Pods in the zones where this limit is exceeded.
#### Pod Topology Spread Constraints can be used with various k8s objects:-
1. Deployments
2. StatefulSets
3. DaemonSets
4. ReplicaSets
5. Jobs and CronJobs
#### Some common use cases:-
1. Deploying a web application with its replicas spread evenly across multiple availability zones to ensure high availability and fault tolerance.
2. Deploying a stateful application, such as a database, with Pods spread across different nodes to prevent data loss in case of node failure.
3. Deploying a batch processing application with workloads distributed across multiple zones to optimize resource utilization and ensure processing continuity.
#### Other mechanisms to achieve balanced Pod distribution and resilience:-
1. Pod AntiAffinity
2. Node Affinity
3. Cluster Autoscaler with Balance-Similar-Node Groups
4. Manual Distribution
5. Custom Schedulers
#### Significant advantages of Pod Topology Spread Constraints over other mechanisms
1. Enhanced Granularity and Control: Pod Topology Spread Constraints allow precise control over Pod distribution across various domains (e.g., zones, nodes), ensuring a balanced deployment with minimal skew between domains.
2. Automation and Simplicity: Unlike Pod AntiAffinity and Node Affinity, which can be complex and require manual management, Pod Topology Spread Constraints automatically balance Pods based on predefined rules, reducing manual effort and errors.
3. Proactive Balancing: This feature ensures Pods are evenly distributed at the time of scheduling, unlike the Cluster Autoscaler which reacts to imbalances after they occur, providing more immediate and consistent balance.
4. Versatility Across Domains: While Node Affinity focuses on nodes, Pod Topology Spread Constraints work across multiple topology domains, making them more versatile for different deployment scenarios.
5. Standardized and Built-In: As a native Kubernetes feature, Pod Topology Spread Constraints offer a standardized approach, eliminating the need for custom schedulers and ensuring compatibility with Kubernetes updates and community support.
| cloudy05 |
1,873,341 | STOLEN CRYPTOCURRENCY ASSET RECOVERY EXPERTS-(FOLKWIN EXPERT RECOVERY | ** FOLKWIN EXPERT RECOVERY emerges as a guiding light, illuminating the path to redemption for... | 0 | 2024-06-01T23:02:30 | https://dev.to/logan_noah_2920cb0686a6f5/stolen-cryptocurrency-asset-recovery-experts-folkwin-expert-recovery-3g15 |
** FOLKWIN EXPERT RECOVERY emerges as a guiding light, illuminating the path to redemption for victims ensnared in the web of online fraud. My journey with them began tentatively, shrouded in skepticism and apprehension, a result of past encounters with false promises and shattered trust. Yet, amidst the darkness, their unwavering dedication and unparalleled expertise soon shattered my doubts, paving the way for a remarkable transformation. From the outset, ** FOLKWIN EXPERT RECOVERY'S commitment to its mission was palpable. Their team of skilled professionals, akin to artisans sculpting from the chaos, meticulously pieced together the fragments of my shattered trust. With each interaction, their transparency and integrity shone brightly, dispelling the shadows of uncertainty that had clouded my judgment. It was evident that they were not merely a service provider but guardians of integrity in the realm of cybersecurity. What truly sets ** FOLKWIN EXPERT RECOVERY apart is its unwavering commitment to client satisfaction. Unlike others who may offer empty promises, they deliver tangible results that surpass mere restitution. With each update and guidance provided, they instilled a sense of hope and reassurance, forging an enduring bond of trust. Their dedication to going above and beyond for their clients is not merely a business ethos but a testament to the triumph of resilience over adversity. In cybersecurity, where threats evolve and multiply with alarming speed, ** FOLKWIN EXPERT RECOVERY stands as a bastion of reliability. Their expertise spans a myriad of fraudulent schemes, from phishing scams to investment fraud, enabling them to navigate the intricate web of deception with precision and finesse. Moreover, their proactive approach to cybersecurity empowers clients with the knowledge and tools necessary to safeguard themselves against future threats. Beyond their technical prowess, ** FOLKWIN EXPERT RECOVERY'S human-centric approach sets them apart. Each client is treated with empathy and respect, and their unique circumstances are carefully considered and addressed with compassion. It is this personalized touch that fosters a sense of trust and camaraderie, transforming what could be a daunting ordeal into a journey of resilience and empowerment. As I reflect on my journey with ** FOLKWIN EXPERT RECOVERY, I am filled with gratitude for their unwavering support and guidance. They have not only restored what was lost but have also imbued me with a newfound sense of confidence and security in the digital realm. In an age where trust is a scarce commodity, their steadfast commitment to integrity serves as a beacon of hope, guiding others out of the shadows and into the light. In the realm of cybersecurity, ** FOLKWIN EXPERT RECOVERY is more than just a service provider; they are champions of justice, advocates for truth, and guardians of trust. For help, Contact them with this info below:
Website: ( WWW.FOLKWINEXPERTRECOVERY.COM
Whatsapp: ( +1 (740)705-0711
Email: ( FOLKWINEXPERTRECOVERY @ TECH-CENTER . COM
Regards,
Mr Logan Noah. | logan_noah_2920cb0686a6f5 | |
1,873,339 | Discover the Best Products of 2024 Curated by Redditors - BuyReddit.com | BuyReddit brings you the top recommended products from Reddit. Popular Products (as of May 2024):... | 0 | 2024-06-01T22:46:37 | https://dev.to/ben_levay_5576197218890ea/discover-the-best-products-of-2024-curated-by-redditors-buyredditcom-591a | react, productivity, showdev | BuyReddit brings you the top recommended products from Reddit.
Popular Products (as of May 2024): https://www.buyreddit.com/popular | ben_levay_5576197218890ea |
1,873,338 | The 8-Hour Debug: How a Silly Mistake Cost Me a Day | The Function function getEnrollmentByStudentIdAndCourseId( studentId: string, ... | 0 | 2024-06-01T22:34:05 | https://dev.to/mmvergara/the-8-hour-debug-how-a-silly-mistake-cost-me-a-day-543e | javascript, webdev, programming | ### The Function
```ts
function getEnrollmentByStudentIdAndCourseId(
studentId: string,
courseId: string
) {
// fetch logic
return result;
}
```
## The Mistake
Believe it or not this function caused me a day of debugging. Because of the way I was calling it like this.
```ts
const studentId = "ID";
const courseId = "ID";
const enrollment = getEnrollmentByStudentIdAndCourseId(courseId, studentId);
```
I was passing the arguments in the wrong order. The function signature was `getEnrollmentByStudentIdAndCourseId(studentId, courseId)` but I was calling it with `getEnrollmentByStudentIdAndCourseId(courseId, studentId)`.
The reason why i took so long debugging it was because function was **still returning a result even though the arguments were in the wrong order**, but it was the wrong result. I think this is ultimately a mistake i made by writing a bad prisma query that caused it.
### The Adjustment
make the argument passing more explicit by using object
```ts
type Args = {
courseId: string;
studentId: string;
};
function getEnrollmentByStudentIdAndCourseId({ courseId, studentId }: Args) {
// fetch logic
return result;
}
```
Ever since then, when I have a function that takes multiple arguments of the same type like IDs, I started to use object destructuring to make the argument passing more. And also like... made better prisma queries.
I hope this helps you avoid the same mistake I made. Happy coding!
| mmvergara |
1,873,337 | [Game of Purpose] Day 14 | Today no progress. I've been taking care of my home. | 27,434 | 2024-06-01T22:33:38 | https://dev.to/humberd/game-of-purpose-day-14-520 | gamedev | Today no progress. I've been taking care of my home. | humberd |
1,873,290 | The Start of E.V.O T | Hey everyone, hope all is well! I've officially started the journey now that I have all the necessary... | 0 | 2024-06-01T22:25:08 | https://dev.to/kevinpalma21/the-start-of-evo-t-ibf | beginners, learning, programming, coding | Hey everyone, hope all is well! I've officially started the journey now that I have all the necessary equipment to build the turret (might be missing a few things, but we'll go with the flow). I've begun creating the AutoCAD design for the base of the turret. This is just the prototype since it's my first time really freestyling this, so bear with me if it looks a bit weird.
I want to make a nice, sturdy base with some vents on the sides to let the components inside breathe. I want the turret to look like a railgun cannon, taking inspiration from the image below (Image 1) but with some tweaks. I have an idea for the base—here's a quick look at what I've got(image2). I want the Arduino to stay in this section of the turret, with the other bulkier equipment here. Once I have this part down, I'll start working on the actual movement of the turret.
 (Image1)
(Image2)
I'm still deciding what kind of motor to use. If you have any suggestions, that would be awesome, and I'm always happy to hear your ideas and talk more about it.
This is the main update I have for you. I'll try to keep you updated every 3-4 days with good progress each time. Just wanted to let you know I haven't abandoned this project and will see it through to the end. Thank you all for the support and have a great one!
Quick pic of my Guinea Pig Yoshi
| kevinpalma21 |
1,873,284 | REST API Design Rules | Why is it important to write clean REST-API Designs In today's interconnected world,... | 0 | 2024-06-01T21:44:05 | https://dev.to/ezekiel_77/rest-api-design-rules-2c4j | webdev, backend, api, design | ## Why is it important to write clean REST-API Designs
In today's interconnected world, well-designed REST APIs are the backbone of efficient and scalable applications.
Writing clean REST API designs is crucial for several reasons:
* **Enhanced Usability:** A well-designed API is intuitive and easy to use, making it accessible to developers of all skill levels. This simplifies integration and reduces the learning curve.
* **Improved Maintainability:** Clean code promotes maintainability by making it easier to identify and fix bugs, add features, and scale the API. This ensures long-term stability and reduces development costs.
* **Increased Security:** A well-structured API with proper authentication and authorization mechanisms helps prevent unauthorized access, data breaches, and other security vulnerabilities.
* **Enhanced Performance:** A clean design optimizes performance by using efficient data structures, avoiding unnecessary calls, and minimizing latency. This provides a seamless user experience and improves overall application performance.
* **Reduced Development Time:** Well-defined API specifications and clear documentation enable faster development by eliminating guesswork and reducing the need for extensive testing. This saves valuable development time and resources.
* **Improved Scalability:** A clean design allows for easy scalability by providing a modular architecture that can be easily expanded to handle increased traffic or new features. This ensures the API can grow with the application's needs.
* **Increased Reusability:** A well-designed API can be reused across multiple applications, reducing duplication and promoting consistency. This simplifies development and saves time and effort.
* **Improved Documentation:** Clean designs are easier to document, making it clear to developers how the API works and how to use it effectively. This reduces confusion and improves adoption.
## URI Rules
**The structure of a url is as follows**
**`scheme :// authority / path [?query][#fragment]`**
for instance
`https://soccer.api.org/teams/dortmund/players?name=Rona#2`
There are two types of resources
1. Collection resources: contains a collection of resources. It can be likened to a database relation
2. Singleton resources: contains a single resource. It can be likened to a database record.
---
When designing Rest-Api's
1 Collection resources should be plural
```diff
+ soccer.api.org/teams/dortmund
- soccer.api.org/team/dortmund
```
2 Singleton resources should be singular and can be replaced by the unique id representing the resource in the database system behind the api
```diff
+soccer.api.org/teams/dortmund/players/58c1aaae-205a-11ef-aeea-a64c74618950
```
3 No **trailing forward slashes** in your URI's
```diff
+soccer.api.org/teams/dortmund/players
-soccer.api.org/teams/dortmund/players/
```
4 Use **hyphens** instead of **underscores** to improve readability of API's
```diff
+ api.blog.com/blogs/this-is-my-blog
- api.blog.com/blogs/this_is_my_blog
```
5 **Lowercase letters** are prefered to **Uppercase letters** in URI paths
```diff
+ api.example.com/my-api/my-resource
- api.example.com/My-Api/My-Resource
```
6 No **file extensions** in URI's
```diff
+ api.example.com/api/resource
- api.example.com/api/resource.json
```
7 CRUD function names should **not** be used in URI's
```diff
+ DELETE api.example.com/api/resource
- GET api.example.com/api.resource/delete
```
8 The query component of the URI's can only be used in collection resources
```diff
+ GET /users?role=admin
```
9 The query component of a URI should be used to paginate collection results
```diff
+ GET /users?pageSize=25&pageStartIndex=50
```
## HTTP Method Rules
| HTTP METHOD | Uses |
| ----------- | ----------------------------------------------------------------------------------------------------------------- |
| POST | To create a new resource. similar to create |
| GET | To get the representation of a resource. similar to read |
| PUT | To update a resource by replacing the **whole** resource |
| DELETE | To delete a resource |
| PATCH | To update a resource by changing the part of the resource that is required without replacing the entire resource. |
| HEAD | To get only the response head not the body |
| OPTIONS | To get all available options for a particular resource |
> PUT can be used for both creating and updating a resource. However, following best practices, it's generally recommended to use POST for creating new resources and PUT for fully replacing existing ones.
---
## Versioning
Versioning an api can be important for:
**Maintaining backward compatibility:** Versioning allows you to introduce new features without breaking existing integrations that rely on older API versions. Users can continue using the familiar endpoints while those seeking new features can adopt the versioned API.
**Ensuring a consistent and well-designed API:** Consistent naming conventions across versions contribute to a user-friendly experience. Changing endpoints disrupts this experience, and versioning helps avoid it.
---
# Conclusion
Now that you're armed with these REST API design rules, it's time to put them into action! Share your API creations in the comments below, and let's build a world of well-designed and developer-friendly APIs together.
| ezekiel_77 |
1,873,282 | Introduction to EigenLayer | Welcome to the first post in our series on EigenLayer! In this series, we'll explore how EigenLayer... | 0 | 2024-06-01T21:32:13 | https://dev.to/gaj/introduction-to-eigenlayer-45ob | crypto, ethereum, blockchain | Welcome to the first post in our series on EigenLayer! In this series, we'll explore how EigenLayer is transforming the Ethereum ecosystem by enabling the creation of Actively Validated Services (AVSs). Whether you're a seasoned developer or new to the world of blockchain, this guide will help you understand and leverage the potential of EigenLayer.
#### What is EigenLayer?
EigenLayer is a decentralized protocol built on the Ethereum blockchain. It introduces a novel concept: the ability to "restake" ETH that is already staked for securing the Ethereum network to provide additional security and validation for new decentralized applications (dApps) and services. This process enhances the utility of staked ETH, allowing it to be used for multiple purposes simultaneously.
#### Key Concepts
1. **Restaking**: This is the cornerstone of EigenLayer. It allows Ethereum stakers to opt-in their staked ETH to secure various AVSs. By doing so, the staked ETH can serve multiple roles without the need for additional capital.
2. **Actively Validated Services (AVSs)**: These are the services and applications that utilize the security provided by restaked ETH. Examples include oracles, bridges, Layer 2 solutions, and more. AVSs benefit from the robust security model of the Ethereum network while adding their own unique functionalities.
3. **Cryptoeconomic Security**: EigenLayer ensures that the restaked ETH is used responsibly. If an operator (like Joe in our previous example) misbehaves or acts maliciously, they get slashed. This means they lose a portion of their staked ETH, which provides a strong incentive to act honestly.
#### How Does EigenLayer Work?
Let’s break down the process using a simple example:
1. **Building an AVS**: Imagine James is a developer who wants to build an oracle service. An oracle provides trusted data feeds, which are crucial for many blockchain applications, like Julien’s lending protocol.
2. **Running the AVS**: Joe, who has significant compute power, decides to run James's oracle service. However, to ensure that Joe behaves correctly, he needs to be economically incentivized.
3. **Providing Security**: Jake, an Ethereum staker, delegates his staked ETH to Joe’s service via EigenLayer. This delegation provides cryptoeconomic security to the oracle service.
4. **Ensuring Integrity**: If Joe reports incorrect data (goes rogue), the protocol slashes his staked ETH. This slashing means Jake loses his staked ETH, covering any potential losses for users like Julien.
#### Why is EigenLayer Important?
EigenLayer brings several key benefits to the Ethereum ecosystem:
- **Enhanced Utility of Staked ETH**: It maximizes the utility of staked ETH by allowing it to secure multiple services.
- **Robust Security**: The cryptoeconomic security model ensures that services are reliable and operators are incentivized to act honestly.
- **Flexible and Composable**: Developers can create a wide range of services, from oracles to Layer 2 solutions, all benefiting from the security provided by EigenLayer.
#### Getting Started with EigenLayer
In the upcoming posts, we’ll dive deeper into how you can start building on EigenLayer. We’ll cover topics like setting up your development environment, creating and deploying AVSs, and best practices for ensuring security and reliability.
Stay tuned as we embark on this journey to explore the limitless possibilities enabled by EigenLayer. Whether you’re looking to enhance existing applications or build new innovative services, EigenLayer provides the foundation to do so securely and efficiently.
Welcome to the future of decentralized services with EigenLayer! | gaj |
1,851,926 | My Top 5 Favorite Algorithm Problems at Codewars | What is codewars? Codewars is a social network of programmers who get together to... | 0 | 2024-06-01T17:36:58 | https://coffeebytes.dev/en/top-5-favorite-algorithm-problems-at-codewars/ | opinion, algorithms, codewars, leetcode | ---
title: My Top 5 Favorite Algorithm Problems at Codewars
published: true
date: 2024-06-01 21:15:00 UTC
tags: opinion,algorithms,codewars,leetcode
canonical_url: https://coffeebytes.dev/en/top-5-favorite-algorithm-problems-at-codewars/
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pdpfqinp1sdqt7rwgtuk.jpg
---
## What is codewars?
Codewars is a social network of programmers who get together to challenge each other to solve code challenges. Codewars is one of **the best websites for practicing algorithms and solving Katas**. Katas? Yes, as in Karate.
### What are katas in codewars?
In the spirit of martial arts, more specifically Karate, these code problems are called _katas_. The _katas_ are divided, ascendingly, according to their difficulty. There are katas from 8th kyu to 1st kyu, with 1st kyu being the most difficult type of _kata_ of all.
There are _katas_ on many, many topics: algorithm development, efficiency, regex, mathematics, cryptography, etc.
Collectively, the _katas_ encompass a variety of languages: C, C++, Go, Python, Javascript, Elixir, Haskell, Rust, even languages as esoteric as Brainfuck. While, individually, each Kata has one or more languages.
Without further ado, here are my top 5 _katas_. These _katas_ **are not necessarily the most difficult ones** , but the ones that I consider to have the ideal balance between creativity and difficulty. I choose those that give that feeling of a good puzzle, one of those that you can’t stop until you solve it.
By the way, **no, I’m not going to post the answers** , those are up to you.
## Multi Line Task++: Hello World
You need to write a function that returns the string “Hello, world!” in Javascript.
Requirement: Each line must have at most 2 characters, and the total number of lines must be less than 40.
Hint: It is possible to complete it in only 28 lines of code.
Original Kata: [Multi Line Task++: Hello World](https://www.codewars.com/kata/59a421985eb5d4bb41000031)
### Note on Kata
The difficult part is the two characters per line maximum. Give it a try.
```
12
34
56
78
//
```
There is a more complicated version where the limit is one character per line, in case you find this one too easy.
## Make a spiral
Your task is to create a spiral of NxN with the given size.
For example, a spiral with 5 sides should look like this:
```
00000
....0
000.0
0...0
00000
```
And size 10
```
0000000000
.........0
00000000.0
0......0.0
0.0000.0.0
0.0..0.0.0
0.0....0.0
0.000000.0
0........0
0000000000
```
The return value should contain an array of arrays, 0’s and 1’s, with the first row consisting of 1’s. For example, for the given size of 5, it should be:
``` python
[[1,1,1,1,1],[0,0,0,0,1],[1,1,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
```
For extreme cases of small spirals, the size will be at least 5.
As a general rule, the snake made of 1s cannot touch itself.
Original Kata: [Make a spiral](https://www.codewars.com/kata/534e01fbbb17187c7e0000c6)
### Note on Kata
It looks easy, but I assure you it won’t be so easy on your first try.
## The soul of wit: reverse an array
No time for stories, invert an array (in Javascript), return the result. Do whatever you want with the original array. Don’t use Array.prototype.reverse.
You have 30 bytes to spend.
Example: [1, 2, 3] → [3, 2, 1].
This time you won’t be able to do the other Kata thing.
Nor can you use require.
Kata original: [The soul of wit: reverse an array](https://www.codewars.com/kata/59b81886460387d8fc000043)
### Note on Kata
By 30 bytes it means that you have the equivalent in characters to use in your code. For example: the solution below has 33 characters, it exceeds the limit and also cannot be used reverse.
``` javascript
const reverse = a => a.reverse();
```
## Last digit of a huge number
Given a list [x1, x2, x3, …, xn] compute the last digit (decimal) of x1 ^ (x2 ^ (x3 ^ (… ^ xn))).
Example:
lastDigit([3, 4, 2]) === 1
because 3 ^ (4 ^ 2) = 3 ^ 16 = 43046721.
Beware: powers grow incredibly fast. For example, 9 ^ (9 ^ 9) has more than 369 million digits. Your lastDigit function has to deal with those numbers efficiently.
Unusual cases: we assume that 0 ^ 0 = 1 and that the last digit of an empty list is equal to 1.
Kata original: [Last digit of a huge number](https://www.codewars.com/kata/5518a860a73e708c0a000027)
### Note on Kata
If you are thinking of writing something like:
``` python
def lastDigit(arr):
# Esta función NO es la correcta
total = 1
for element in arr[::-1]:
total = element ** total
return str(total)[-1]
last_digit([528374,27415,789392,462589,166837,699678,866982])
```
Solutions like this will get you nowhere, the Kata has to run incredibly fast.
See how long it takes to run in Python with the correct lastDigit function.
``` bash
time python script.py
real 0m0.122s
user 0m0.073s
sys 0m0.044s
```
If you try to run the above code you can probably go make a cup of coffee before it finishes executing.
## Escape the maze
You are provided with a complete labyrinth, like a 2-dimensional grid, more specifically in your language: an array of strings.
maze[0][0] is the upper left corner maze[maze[maze.length - 1][maze[0].length - 1] is the lower right corner
Within this 2D grid:
``` bash
' ' Free space you can walk through
'#' bush with thorns (You can't walk through it)
'^', '<', 'v' or '>' Your body facing to north, west, south or east, respectively.
```
Original Kata: [Escape the maze](https://www.codewars.com/kata/5877027d885d4f6144000404)
### Note on Kata
You are given a series of mazes, your position and you must provide an array of moves to get out. It’s incredibly entertaining!
``` javascript
[ '##########',
'# #',
'# ##### #',
'# # # #',
'# #^# # #',
'# ### # #',
'# # #',
'######## #' ]
```
## Katas with honorable mention
There are other Katas that I like very much but they were left out of this top. Check them out.
- [The Millionth Fibonacci Kata](https://www.codewars.com/kata/53d40c1e2f13e331fc000c26)
- [Prime Streaming [NC-17]](https://www.codewars.com/kata/59122604e5bc240817000016)
- [Breaking the Vigenère Cipher](https://www.codewars.com/kata/544e5d75908f2d5eb700052b)
- [Escape the Maze](https://www.codewars.com/kata/5877027d885d4f6144000404)
- [Simple Maze](https://www.codewars.com/kata/56bb9b7838dd34d7d8001b3c)
- [Sum strings as numbers](https://www.codewars.com/kata/5324945e2ece5e1f32000370)
- [Elemental words](https://www.codewars.com/kata/56fa9cd6da8ca623f9001233) | zeedu_dev |
1,873,038 | Por que o Dia 31 Causa Problemas e Como Solucioná-los | Manipular datas é uma tarefa comum, mas pode se transformar em um verdadeiro desafio, especialmente... | 0 | 2024-06-01T21:06:18 | https://dev.to/yagocosta/por-que-o-dia-31-causa-problemas-e-como-soluciona-los-50ba | Manipular datas é uma tarefa comum, mas pode se transformar em um verdadeiro desafio, especialmente no fim dos meses. Vamos explorar por que os bugs são mais frequentes no dia 31 e como evitá-los em PHP/Laravel e JavaScript.
## Como Datas Funcionam
Antes de mais nada, precisamos entender brevemente como as datas funcionam na programação. Datas são geralmente tratadas como o número de milissegundos desde 1 de janeiro de 1970, a famosa **Época Unix**. Essa representação numérica permite manipular datas com operações matemáticas simples. No entanto, o problema surge quando tentamos ajustar datas em meses com diferentes números de dias.
## O Problema com a Manipulação de Datas
Cada mês tem um número diferente de dias, o que pode causar problemas quando tentamos passar de um mês para outro. Por exemplo, se você começa com uma data no dia 31 e tenta ir para o mês seguinte, o resultado pode ser inesperado porque nem todos os meses têm 31 dias.
## Exemplo em JavaScript
Imagine que você está construindo um calendário e precisa navegar pelos meses.
```javascript
const toggleMonth = (type) => {
let date = new Date(selectedYear, selectedMonth, selectedDay);
if (type === 'next') {
date.setMonth(date.getMonth() + 1);
}
if (type === 'previous') {
date.setMonth(date.getMonth() - 1);
}
setSelectedYear(date.getFullYear());
setSelectedMonth(date.getMonth());
setSelectedDay(date.getDate());
};
```
### Resultado do Código Problemático
Suponha que `selectedYear` seja 2023, `selectedMonth` seja 4 (maio) e `selectedDay` seja 31.
- Quando incrementamos o mês, `date.setMonth(date.getMonth() + 1)` muda para junho, mas como junho tem apenas 30 dias, o navegador ajusta automaticamente para 1 de julho.
**Solução:**
```javascript
const toggleMonth = (type) => {
let date = new Date(selectedYear, selectedMonth, 1); // Comece do primeiro dia do mês
if (type === 'next') {
date.setMonth(date.getMonth() + 1);
} else if (type === 'previous') {
date.setMonth(date.getMonth() - 1);
}
const lastDayOfMonth = new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
setSelectedDay(Math.min(selectedDay, lastDayOfMonth)); // Ajuste o dia se necessário
setSelectedYear(date.getFullYear());
setSelectedMonth(date.getMonth());
};
```
Aqui, começamos no dia 1 do mês e depois ajustamos para garantir que não vamos para um dia que não existe no mês. Isso evita que 31 de maio se transforme em 1 de julho ao invés de 30 de junho.
## Exemplo em PHP/Laravel
No Laravel, imagine que você quer pegar o último dia do mês anterior:
**Código Problemático:**
```php
$lastDayOfPreviousMonth = Carbon::now()->subMonth()->endOfMonth();
```
### Resultado do Código Problemático
Imagine que hoje seja 31 de março:
- Usando `Carbon::now()->subMonth()`, a data muda para 3 de março (em anos não bissextos).
- Quando aplicamos `->endOfMonth()`, a data é ajustada para o último dia de março, resultando em 31 de março, o que não é o esperado.
**Solução:**
```php
$lastDayOfPreviousMonth = Carbon::now()->startOfMonth()->subMonth()->endOfMonth();
```
Nesta solução, garantimos que começamos no primeiro dia do mês atual antes de subtrair um mês. Isso evita problemas ao lidar com meses de diferentes durações. Dessa forma, se hoje for 31 de março, o código corretamente retorna 28 ou 29 de fevereiro, conforme o caso.
## Conclusão
Manipular datas pode ser complicado, especialmente no final dos meses. Começando de uma data segura e ajustando conforme necessário, você pode evitar muitos bugs comuns. Aplique essas melhorias no seu código e evite dores de cabeça em momentos cruciais!
## Referências
- [Documentação do Carbon](https://carbon.nesbot.com/docs/)
- [MDN Web Docs - Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) | yagocosta | |
1,873,263 | HOW TO RECOVER YOUR CRYPTOCURRENCY FROM SUSPICIOUS INVESTMENTS AND ONLINE TRADING | my experience with Trust Geeks Hack Expert was transformative. They recovered my lost funds and... | 0 | 2024-06-01T20:45:56 | https://dev.to/cely-fernandez/how-to-recover-your-cryptocurrency-from-suspicious-investments-and-online-trading-2e79 | general, beginners, bitcoin, tutorial | my experience with Trust Geeks Hack Expert was transformative. They recovered my lost funds and provided invaluable support during a tumultuous period. Their professionalism, expertise, and dedication to helping victims of fraud are commendable. While I hope no one else endures what I did, knowing that services like Trust Geeks Hack Expert offer a beacon of light for those in similar predicaments like crypto theft or investment scams. Send a DM to Trust Geeks Hack Expert through the email: info@trustgeekshackexpert.com $ TelegramID: Trustgeekshackexper
 | cely-fernandez |
1,873,262 | Need Suggestion | visit my portfolio website at https://abdullahs-portfolio.vercel.app/ Hi so its not one of the... | 0 | 2024-06-01T20:38:50 | https://dev.to/abdullah_ali_eb8b6b0c2208/need-suggestion-2i8g | javascript, webdev, beginners, career | **visit my portfolio website at
https://abdullahs-portfolio.vercel.app/**
Hi so its not one of the reading article i needed suggestion.
so i was creating an project for my profolio that is like an simple blogging website using mern
it already have
- login signup logout (jwt)
- create blog
- view blog
- search blog
- display blog ( pagination)
- profile view and edit
apart from theese suggest me what should i add more into website of **ML OR AI **
so that my project can be good for portfolio
_visit my portfolio website at
https://abdullahs-portfolio.vercel.app/_ | abdullah_ali_eb8b6b0c2208 |
1,873,260 | Take me to a Beach! T-T | This is a submission for [Frontend Challenge... | 0 | 2024-06-01T20:29:27 | https://dev.to/dhrutisubham03/take-me-to-a-beach-t-t-5c5a | devchallenge, frontendchallenge, css, javascript | _This is a submission for [Frontend Challenge v24.04.17]((https://dev.to/challenges/frontend-2024-05-29), Glam Up My Markup: Beaches_
## What I Built
I was trying to build a table on a beach that would show different beaches in the form of cards. I wanted to give it a relaxed and "beachy" look with the help of textures and warm colors.
## Demo
I have made this for PC screens only(Pardon me for being lazy). Best viewed in 1024x532.
Keyboard Inputs are also supported:
```
SpaceBar: To begin exploring.
Left and Right Arrows: To navigate the gallery.
Escape: To exit the gallery and move to landing page.
```
{% codepen https://codepen.io/dhrutisubham/pen/vYwxyNR %}
_Edit: I am facing some issues with applying a hosted font on codepen. Make sure you check out netlify site as well :)_
_[View the full code here](https://github.com/dhrutisubham/glam-up-dhrutisundar)_
_[Hosted on Netlify as well](https://beaches-damn.netlify.app/)_
## Journey
I was excited to participate in the frontend challenges(Yes! This is the first time :P). When I saw the topic, I started diving deep into all kinds of illustrations(Freepik) and fonts(Google Fonts and Google Search :P) I could collect to get something into shape.
I thought showing different beaches on paper cards would be simple and cool. So, I dived into Figma and built a desktop screen for the landing page.
Given that beaches are filled with shuttle movements of nature(waves, wind and creatures), I wanted to add some transitions and animations with the help of [GSAP](https://gsap.com/). I was also dreaming of putting a crab that would randomly crawl in and out, but I decided to be happy with being able to imagine it.(Laziness-2 Me-0)
##Credits
Illustrations: [Freepik](freepik.com)
Beach Images: [Google Images](images.google.com)
Fonts: [Beach](https://www.1001fonts.com/beach-font.html), [Josefin Sans](https://fonts.google.com/specimen/Josefin+Sans)
Transitions: [GSAP](https://gsap.com/)
| dhrutisubham03 |
1,873,259 | Buying a Refurbished Laptop: Both Sides of the Picture | There is a time that comes to you when you have tried a lot in saving just to buy a new laptop but... | 0 | 2024-06-01T20:29:25 | https://dev.to/liong/buying-a-refurbished-laptop-both-sides-of-the-picture-303h | laptops, refurbished, malaysia, kualalumpur | There is a time that comes to you when you have tried a lot in saving just to buy a new laptop but when these refurbished laptops came into being, they then from that time onwards are considered to be the most common and best option one could ever do. So, my point to you is that this modernized tech world has the greatest and the latest kinds of technology gadgets, etc. At this time, middle-class or normal people like us who survive on the budget system then can choose the best option is refurbished laptops. However, when you are getting something it always has its very own advantages and disadvantages just like giving us both sides of the picture.
Owning top-quality devices at noticeably decreased prices is possible with these carefully checked and restored pre-owned devices. But before you go into the universe of refurbished laptops, it's important to know the advantages and disadvantages of this decision.
## The Good Side: Why [Refurbished Laptops](https://ithubtechnologies.com/benefits-of-refurbished-laptops/?utm_source=dev.to&utm_campaign=refurbishedlaptops&utm_id=Offpageseo+2024) Shine
You need to know that other than getting yourself stressed by the costly payments or prices of gadgets. Here, you can check for refurbished laptops as an option too. The following are the reasons why these laptops are the best of their kind.
1. **Cost-Effectiveness:** When we talk about money problems or costs, the most important kind of benefit that is given by refurbished laptops is their cheap process. The prices are to some extent 30- 50% decreased or reduced as compared to the original newest one. Our new generation, like the students themselves, buy the latest and newest quality laptops or gadgets just to make themselves seem to be more attractive and up to date with trends. These refurbished laptops play an awesome role in helping out the budget-friendly living people or students who survive on their pocket money. If they look for the newest models of top companies laptops, then they won't be able to afford them.
2. **Environmentally Friendly:** Whenever you are buying something, it must be sustainable and environmentally friendly for the user itself too. Here at this point these refurbished laptops work best. This is a good option as you give a new life to the device by restoring it and replacing the old parts. Buying refurbished laptops reduces electronic waste. It has a very reduced impact on the environment.
3. **Quality and Performance:** The refurbishers are working as an expert to restore such old tech. This may include their safe working steps of processes that are done in such a way as to restore and repair everything in order. Then this will automatically assure you that you are not getting outdated repaired stuff but you are getting the newest quality etc.
The refurbishers not only just update everything but also add up more storage capacity and RAM.
4. **Many Options:** Our refurbished market is not limited because it has opened up doors for showing people every type and kind of laptop. Whether the laptops are of top-rated companies like DELL, Apple, HP, etc. Here in the market you can get older laptops but at a much lower price than their original prices, it's like paying half the price of a laptop according to their original prices.
5. **Warranties and Guarantees:** Many respected refurbishers have made their loyal customers and increased their sales by providing them with warranty options. They provide warranties and guarantees on their devices, also offering peace of mind and protection against potential issues. They also provide future consultations regarding laptops or tech problems.
### The Other Side of the Coin: Potential Drawbacks to Consider
Now, you have a refurbished laptop and you are going through some kinds of complications or problems because of it. The most common types of problems that occur due to refurbished laptops are listed in the following:
- **Unknown History:** Let's talk about some history of your tech refurbished laptop. These laptops undergo so many processes by the refurbisher that it has to be properly tested and you know the exact reason why these laptops return. The mini errors, am I right? Some of the laptops may have fewer issues but some have many mini minor repairs they need.
- **Cosmetic Errors:** We buy laptops, but we forget to take care of their look and interior. Then at the end of the day, many small dents, scratches or even wear or tear are seen on the laptop. However, they should not be affecting its working system but still, it's something to consider when you are looking for the aesthetic look of your tech or gadget.
- **Limited Availability**: In the market of refurbished laptops, you most of the time can face the problem of not finding the model of what you are looking for or sometimes you are not able to get the latest edition which is limited in stock.
- **Warranty Time:** This will give you the idea that refurbished laptop warranties are usually most of the time shorter than the new devices because the new devices have more latest top quality so a longer warranty is given to the user who buys it. You must be very sure to check the warranty length and terms before deciding to purchase it.
- **Possibility for Hidden Issues:** While rarely, there's a slight chance that even after testing, a refurbished laptop might develop unforeseen issues.
## Making an Informed Choice: Tips for Buying Refurbished Laptops
1. **Choose a Reputable Seller:** Here you must find a stone expert as a refurbisher who gives the best customer service and also research as to what processes he/she does.
2. **Carefully Check the Laptop:** Here you need to first check the laptop by checking its looks of dents and working parts.
3. **Verify the Specifications:** This includes that you need to be sure whether this refurbished laptop is meeting your needs.
4. **Check the Warranty:** You must check the warranty time that is given by the refurbisher.
5. **Ask Questions:** You need to ask questions to verify each and everything.
## Conclusion:
According to the above mentioned points, it can be concluded that whether you use refurbished laptops or not, you still need to be aware of the advantages and disadvantages. There comes a time when you have to decide to buy a new laptop so you move onto the idea of buying a refurbished laptop. In this process, you must check the pros and cons, then you need to do a little research on the best refresher you can find and then at last through such homework, you can buy the best top quality fantastic high-quality demand device.
| liong |
1,873,258 | What state management system should I use with React Query for my MERN Stack project? | Hi Dev.io community, I'm currently working on a project using the MERN Stack (MongoDB, Express.js,... | 0 | 2024-06-01T20:28:58 | https://dev.to/said96dev/what-state-management-system-should-i-use-with-react-query-for-my-mern-stack-project-40hi | Hi Dev.io community,
I'm currently working on a project using the MERN Stack (MongoDB, Express.js, React, Node.js) and I'm planning to use React Query for handling server state and data fetching. Given this setup, what state management system would you recommend for managing the client-side state in my application?
To provide more context, I have experience with both the Context API and Redux Toolkit. Additionally, the project involves a complex database structure, so I need a robust solution that integrates well with React Query and can handle intricate state management requirements.
Thanks for your suggestions!
| said96dev | |
1,873,257 | The No-Cheat Code Challenge - Surviving The Odin Project | Hi, it’s Blazej, At the beginning of my coding learning journey, I promised myself I would not... | 0 | 2024-06-01T20:23:57 | https://codebyblazej.com/posts/no-cheat-code-challenge/ | beginners, webdev, javascript, learning | Hi, it’s Blazej, At the beginning of my coding learning journey, I promised myself I would not cheat.
## What Do I Mean by Cheating?
When solving any exercise, I promised myself I wouldn’t look up the solution until my own code was working.
## Choosing The Odin Project
I decided to go with The Odin Project because I was tired of Udemy courses and YouTube videos, which were not bad by any means, but I felt like they weren’t getting me anywhere.
I found it hard to focus after just three minutes of watching each video, and my thoughts would start to drift away. But this is the subject for another blog post.
## Diving into The Odin Project
The Odin Project curriculum is based on reading documentation and solving exercises, making projects, reading more documentation, solving even more exercises, and building even more projects that, as you guessed, become more difficult as you progress.
Everything was fine until I reached this point:
## The Challenge of Palindromes and Fibonacci
I remember it was a long weekend, and I spent all 4 days trying to solve everything. The first few exercises went smoothly, but I got stuck on Palindromes (which I eventually solved) and Fibonacci.
Oh yes… That was a killer. But you might ask, there are no such exercises listed in the above picture, right? Yes, but as you go to the mentioned repository, you will find them in the 8th and 9th positions.
It took me so long to solve the previous exercises that I lost track of where I was supposed to stop and just kept going.
## The Struggle with Fibonacci
I was thinking hard, having tea after tea. As time passed by, my thoughts started drastically changing from “it’s all simple, I will do it” to “something is probably wrong, my thought process seems to be right, there must be some mistake in the exercise itself. Maybe I should look up the solution?”
When I study, I use the [Pomodoro technique](https://www.toptal.com/project-managers/tomato-timer): 25 minutes of focus followed by a 5-minute break.
Pomodoros were passing by, and I managed to get to the point where I was able to get some sort of Fibonacci sequence… but it still seemed not right.
## The Moment of Temptation
At this moment, I thought, “Ok, I got to this point, there is probably something I will learn later on, so I can have a look at the solution and just move on.”
I did as I thought… Of course, I was like, “Oh yeah, it’s that easy and logically thought out. Ok, let’s move on then!”
## Realizing the Mistake
After Fibonacci, there was an object exercise to be solved, and I was confused because we hadn’t gotten to objects at that point in TOP yet.
And I was right, I went a few lessons ahead by mistake…
It only assured me that cheating was the right thing, and I would soon learn something new that would make me solve it later or with more ease. Haha!
## Returning to Palindromes and Fibonacci
A couple of lessons passed, which took me around a week to go through, and I was back at Palindromes and Fibonacci. This time, a little bit stressed though…
Palindromes went smoothly, and I sat down to do Fibonacci. I have to mention here that when I opened the file with the exercise, it was of course solved, so I tried not to look at the code much.
I just marked everything and deleted it. However, I remembered that the first line was:
`let fib = [];`
## The Final Struggle
I began solving it. Nothing was working. I decided to make dinner and go for a walk. Every single time I was away from the computer, my brain was racing back to Fibonacci.
I felt like I had VSCode running in my head. I swear, instead of seeing chips cooking in my air fryer, I could only see lines of Fibonacci code (especially that bloody loop and ‘if’ statement).
The funny feeling was, of course, imagining some solution just to realize 5 seconds later that either I had already tried this or simply realized that JavaScript doesn’t work like that at all!!!
## Breakthrough Moments
I ate and went for a walk. 1 hour of walking = 1 hour of deep thinking. I had 3 new solutions written in my notes, and was 100% sure they would work.
Guess which of those worked out. Yes, you are right, NONE! I was still getting the same results. At that moment, I thought about adding something to the array.
I knew I needed something there. But deep in my brain, I was getting the response, “When you deleted the solved exercise before, that array was empty though.” I just lied to myself.
## Sticking to My Principles
I went back to reading documentation and some articles, but I knew I couldn’t cheat this time. I had already learned that cheating doesn’t help in the long run, and I would just face the same issue later if I cheated now.
Three hours passed. I wasn’t frustrated anymore. I wanted this to be solved, and I wanted to understand what I was doing wrong. I also felt as if I knew how this loop was working, and it seemed to me that I had already tried every single configuration with conditional statements.
## Asking for Help
The only solution I had in my head was to reach out for help on the Discord channel.
## The Solution and Lessons Learned
I solved it!!!! Look, I had to put values into that array and pull the conditional before the loop. That’s what my brain was actually telling me 10 or more hours before.
But because I had seen a little bit of the solution, I kept lying to myself not to do it, believing it was different. Ehh.
## Conclusion
The second lesson I learned on this day was to, of course, ask for help. But I strongly encourage everyone to go through the process of reading documentation and trying to solve everything on their own, especially when you are still learning.
I learned a ton during this process and believe that I will not make this mistake again.
Now I am much more ready to hit another wall with some other exercise. I am familiar with the process now! | codebyblazej |
1,873,256 | The Essential Guide to Hiring Flint Roofing Contractors | When it comes to maintaining the structural integrity and aesthetic appeal of your home, having a... | 0 | 2024-06-01T20:21:33 | https://dev.to/codysavell/the-essential-guide-to-hiring-flint-roofing-contractors-3do9 | When it comes to maintaining the structural integrity and aesthetic appeal of your home, having a reliable roof is crucial. Hiring experienced[ Flint roofing contractors](https://waze.com/ul/h9vspq0ddy) can make all the difference in ensuring that your roofing project is completed efficiently and effectively. Whether you need roof repairs, replacements, or new installations, skilled professionals in Flint offer a range of services to meet your needs.
**Why Choose Local Expertise?**
Flint roofing contractors possess a unique understanding of the local climate and environmental factors that affect roofs in the area. This insight allows them to recommend materials and solutions best suited for homes in Flint. Choosing local contractors ensures that you receive personalized service tailored to your specific needs.
Local contractors are also well-versed in regional building codes and regulations, which is critical when obtaining permits and ensuring that the work complies with legal standards. Their familiarity with local suppliers often results in quicker project completion times and access to high-quality materials.
**Range of Services Offered**
Flint roofing contractors provide a comprehensive array of services designed to address any roofing issue you may encounter:
Roof Repair: From minor leaks to significant damage caused by storms, these professionals can diagnose problems accurately and execute repairs efficiently.
Roof Replacement: When repairs are no longer feasible or cost-effective, replacing the roof might be necessary. Experienced contractors will guide you through selecting suitable materials and executing an installation.
New Roof Installations: Building a new home or adding an extension? Skilled teams can install roofs from scratch, ensuring that they are structurally sound and aesthetically pleasing.
**Importance of Quality Materials**
The longevity and durability of your roof heavily depend on the quality of materials used. Reputable Flint roofing contractors prioritize using high-grade materials from trustworthy suppliers. This commitment not only guarantees lasting performance but also enhances the safety and comfort of your home.
When opting for a roof replacement or installation, these contractors will present various material options such as asphalt shingles, metal roofing, tiles, or even eco-friendly alternatives like green roofs made from natural vegetation. Each option has its advantages; experts can help homeowners decide based on their preferences and budget constraints.
**Process Explained - What To Expect**
Hiring Flint roofing contractors starts with an initial consultation where they evaluate your current roof condition or discuss plans for new installations. During this phase, expect detailed assessments involving measurements, material inspections (if applicable), discussing design preferences/cost estimates before agreeing upon finalizing contracts outlining timelines & pricing structures transparently.
Once everything’s settled satisfactorily both parties sign off binding agreements giving way towards meticulously planning every step ahead minimizing disruptions caused daily routines clients live unaffected throughout entire process till project ends fulfilling expectations promised upfront leaving enduring impressions about quality service received end results delivered hoped-for satisfaction levels exceeded anticipated further recommendations down line future prospects seeking similar assistance trusting capabilities delivering outstanding outcomes continually proving worth hiring right professional team handling delicate tasks demands utmost diligence care attention detail paramount success-driven goals homeowners backyard surrounding community alike welcoming endeavors fostering stronger bonds mutual respect cooperation aiming sustainable growth elevate standards industry practices establishing benchmarks others aspire achieving someday hallmark proficiency devotion excellence cornerstone reputation built around founding principles integrity reliability craftsmanship embodied philosophy guiding endeavors today tomorrow!
**Maintenance Tips Post Installation/Repair Work Completion Ensuring Longevity **
After completing any major repairing/replacement works performed atop houses follow-up maintenance routine becomes vital to preserve integrity investment made in the long run!
Consider scheduling annual inspections conducted OSHA compliant certified experts catching early signs deterioration frost penetrations potentially catastrophic scenarios avoiding costly emergency interventions proactive measures implemented timely bases extending lifespan significantly reducing chances needing another round extensive renovations coming years neighbors witnessing firsthand benefits enjoying peace mind associated knowing job indeed well-done.
In conclusion, securing reliable adept infected proficient Flint roofing contractors forms vital essence intrinsic ensuring durable resilient efficient enhancing beauty aligned homeowner aspirations flourishing grounds fostering symbiotic relations rooted based trust transparent dealings delivering superior outcome envisioned beyond fruition promised accepted setting exemplary model inspiring collective admiration acknowledgment witnessed gained accolades deservedly earned sustained continuous values upheld cherished passed generations nurturing growth enriched experiences enhancing communal welfare serving epitomizing quintessential embodiment professional excellence achieved preserved unwavering dedication standard-bearers exemplifying should synthesis evolution progressive enduring relevancy impactful interventions poised redefining paradigms sector!
**[Bad Bear Roofing and Construction](https://www.badbearroofing.com/)**
Address: [18254 Springmill Ct, Flint, Texas 75762](https://www.google.com/maps/place/?cid=6515012325468345952)
Phone: 903-608-6033
| codysavell | |
1,873,255 | Error Boundary in React js | In React, an Error Boundary is a component that helps catch JavaScript errors anywhere in their child... | 0 | 2024-06-01T20:16:13 | https://dev.to/imashwani/error-boundary-in-react-js-1n5o | react, webdev, javascript, programming | In React, an Error Boundary is a component that helps catch JavaScript errors anywhere in their child component tree, log those errors, and display a fallback UI instead of crashing the entire application. This feature is particularly useful for improving the user experience by gracefully handling unexpected errors.
## **Key Concepts of Error Boundaries**
**1. Definition and Use:**
Error boundaries are React components that catch errors during rendering, in lifecycle methods, and in constructors of the whole tree below them.
They do not catch errors for:
- Event handlers (use try-catch in the event handler).
- Asynchronous code (e.g., setTimeout or requestAnimationFrame
callbacks).
- Server-side rendering.
- Errors thrown in the error boundary itself (e.g., inside componentDidCatch).
**2. How to Create an Error Boundary:**
> An error boundary is any React component that implements either componentDidCatch lifecycle method or the static getDerivedStateFromError method.
```
import React from 'react';
class ErrorBoundary extends React.Component {
constructor(props) {
super(props);
this.state = { hasError: false };
}
static getDerivedStateFromError(error) {
// Update state so the next render will show the fallback UI.
return { hasError: true };
}
componentDidCatch(error, errorInfo) {
// You can also log the error to an error reporting service
console.error("Error caught by ErrorBoundary:", error, errorInfo);
}
render() {
if (this.state.hasError) {
// You can render any custom fallback UI
return <h1>Something went wrong.</h1>;
}
return this.props.children;
}
}
```
**3. Using an Error Boundary:**
```
<ErrorBoundary>
<AppComponet />
</ErrorBoundary>
```
## **Best Practices**
**1. Granularity:**
It's better to place error boundaries at the top level of your application to catch all errors, but you can also place them around specific components to isolate errors within specific parts of your app.
**2. Logging:**
Implement logging in componentDidCatch to send error details to an error monitoring service (e.g., Sentry, LogRocket).
**3. Fallback UI:**
Make sure the fallback UI is user-friendly and provides a way to recover from the error if possible (like a "Try Again" button).
## **Limitations.**
**1. Event Handlers:**
Error boundaries do not catch errors inside event handlers. You need to handle those manually using try-catch blocks.
**2. Async Code:**
Errors in asynchronous code should be handled within the async functions using try-catch blocks.
## **Example in Functional Components**
With the introduction of hooks, you might wonder about using error boundaries in functional components. As of now, React does not provide hooks for error boundaries. You must use class components for creating error boundaries.
In summary, React's Error Boundaries are a robust way to handle errors gracefully in your application, ensuring that users have a smooth experience even when something goes wrong.
| imashwani |
1,873,254 | AVIF Studio - Chrome Extension made with Svelte and WebAssembly for Image Editing & Annotation | AVIF STUDIO Chrome Extension made with Svelte and WebAssembly for Image Editing &... | 0 | 2024-06-01T20:12:28 | https://dev.to/vshareej/avif-studio-chrome-extension-made-with-svelte-and-webassembly-for-image-editing-annotation-558i | svelte, webassembly, avif | ## AVIF STUDIO
Chrome Extension made with Svelte and WebAssembly for Image Editing & Annotation
[LINK TO INSTALL](https://chromewebstore.google.com/detail/avif-studio/bcnhebdciabcnffgcgdpkkniplccpfap?hl=en)
{% youtube qe9Q6XdJYow %}
AVIF Studio is a simple Chrome extension for basic image conversion and image editing.
You can convert images to multiple image formats including AVIF, PNG, WEBP , JPEG & PDF. AVIF Studio can also be used to create customized photo collages. Various templates are available that can be customized to suit your requirements and use cases.
AVIF Studio is equipped with the tools to remove the background from your images and then add new background images of your choice.
The Image processing utilities are developed with WebAssembly integrated with Svelte. That means all the image processing operations including AI operations and image format conversions are taking place inside our browser and there is no need to upload our images to any server for processing. Your images will never leave your computer / browser. This gives you 100% data privacy and security.
| vshareej |
1,873,253 | Buy verified cash app account | https://dmhelpshop.com/product/buy-verified-cash-app-account/ Buy verified cash app account Cash app... | 0 | 2024-06-01T20:11:28 | https://dev.to/agduvejwhis180/buy-verified-cash-app-account-1nok | ERROR: type should be string, got "https://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nBuy verified cash app account\nCash app has emerged as a dominant force in the realm of mobile banking within the USA, offering unparalleled convenience for digital money transfers, deposits, and trading. As the foremost provider of fully verified cash app accounts, we take pride in our ability to deliver accounts with substantial limits. Bitcoin enablement, and an unmatched level of security.\n\nhttps://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nOur commitment to facilitating seamless transactions and enabling digital currency trades has garnered significant acclaim, as evidenced by the overwhelming response from our satisfied clientele. Those seeking buy verified cash app account with 100% legitimate documentation and unrestricted access need look no further. Get in touch with us promptly to acquire your verified cash app account and take advantage of all the benefits it has to offer.\n\n\nhttps://dmhelpshop.com/product/buy-verified-cash-app-account/\n\n\nWhy dmhelpshop is the best place to buy USA cash app accounts?\nIt’s crucial to stay informed about any updates to the platform you’re using. If an update has been released, it’s important to explore alternative options. Contact the platform’s support team to inquire about the status of the cash app service.\n\nClearly communicate your requirements and inquire whether they can meet your needs and provide the buy verified cash app account promptly. If they assure you that they can fulfill your requirements within the specified timeframe, proceed with the verification process using the required documents.\n\nhttps://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nOur account verification process includes the submission of the following documents: [List of specific documents required for verification].\n\nGenuine and activated email verified\nRegistered phone number (USA)\nSelfie verified\nSSN (social security number) verified\nDriving license\nBTC enable or not enable (BTC enable best)\n100% replacement guaranteed\n100% customer satisfaction\nWhen it comes to staying on top of the latest platform updates, it’s crucial to act fast and ensure you’re positioned in the best possible place. If you’re considering a switch, reaching out to the right contacts and inquiring about the status of the buy verified cash app account service update is essential.\n\nClearly communicate your requirements and gauge their commitment to fulfilling them promptly. Once you’ve confirmed their capability, proceed with the verification process using genuine and activated email verification, a registered USA phone number, selfie verification, social security number (SSN) verification, and a valid driving license.\n\nAdditionally, assessing whether BTC enablement is available is advisable, buy verified cash app account, with a preference for this feature. It’s important to note that a 100% replacement guarantee and ensuring 100% customer satisfaction are essential benchmarks in this process.\n\nHow to use the Cash Card to make purchases?\nTo activate your Cash Card, open the Cash App on your compatible device, locate the Cash Card icon at the bottom of the screen, and tap on it. Then select “Activate Cash Card” and proceed to scan the QR code on your card. Alternatively, you can manually enter the CVV and expiration date. How To Buy Verified Cash App Accounts.\n\nAfter submitting your information, including your registered number, expiration date, and CVV code, you can start making payments by conveniently tapping your card on a contactless-enabled payment terminal. Consider obtaining a buy verified Cash App account for seamless transactions, especially for business purposes. Buy verified cash app account.\n\nWhy we suggest to unchanged the Cash App account username?\nTo activate your Cash Card, open the Cash App on your compatible device, locate the Cash Card icon at the bottom of the screen, and tap on it. Then select “Activate Cash Card” and proceed to scan the QR code on your card.\n\nhttps://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nAlternatively, you can manually enter the CVV and expiration date. After submitting your information, including your registered number, expiration date, and CVV code, you can start making payments by conveniently tapping your card on a contactless-enabled payment terminal. Consider obtaining a verified Cash App account for seamless transactions, especially for business purposes. Buy verified cash app account. Purchase Verified Cash App Accounts.\n\nSelecting a username in an app usually comes with the understanding that it cannot be easily changed within the app’s settings or options. This deliberate control is in place to uphold consistency and minimize potential user confusion, especially for those who have added you as a contact using your username. In addition, purchasing a Cash App account with verified genuine documents already linked to the account ensures a reliable and secure transaction experience.\n\n https://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nBuy verified cash app accounts quickly and easily for all your financial needs.\nAs the user base of our platform continues to grow, the significance of verified accounts cannot be overstated for both businesses and individuals seeking to leverage its full range of features. How To Buy Verified Cash App Accounts.\n\nFor entrepreneurs, freelancers, and investors alike, a verified cash app account opens the door to sending, receiving, and withdrawing substantial amounts of money, offering unparalleled convenience and flexibility. Whether you’re conducting business or managing personal finances, the benefits of a verified account are clear, providing a secure and efficient means to transact and manage funds at scale.\n\n\nhttps://dmhelpshop.com/product/buy-verified-cash-app-account/\nWhen it comes to the rising trend of purchasing buy verified cash app account, it’s crucial to tread carefully and opt for reputable providers to steer clear of potential scams and fraudulent activities. How To Buy Verified Cash App Accounts. With numerous providers offering this service at competitive prices, it is paramount to be diligent in selecting a trusted source.\n\nThis article serves as a comprehensive guide, equipping you with the essential knowledge to navigate the process of procuring buy verified cash app account, ensuring that you are well-informed before making any purchasing decisions. Understanding the fundamentals is key, and by following this guide, you’ll be empowered to make informed choices with confidence.\n\n https://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nIs it safe to buy Cash App Verified Accounts?\nCash App, being a prominent peer-to-peer mobile payment application, is widely utilized by numerous individuals for their transactions. However, concerns regarding its safety have arisen, particularly pertaining to the purchase of “verified” accounts through Cash App. This raises questions about the security of Cash App’s verification process.\n\nUnfortunately, the answer is negative, as buying such verified accounts entails risks and is deemed unsafe. Therefore, it is crucial for everyone to exercise caution and be aware of potential vulnerabilities when using Cash App. How To Buy Verified Cash App Accounts.\n\nCash App has emerged as a widely embraced platform for purchasing Instagram Followers using PayPal, catering to a diverse range of users. This convenient application permits individuals possessing a PayPal account to procure authenticated Instagram Followers.\n\nLeveraging the Cash App, users can either opt to procure followers for a predetermined quantity or exercise patience until their account accrues a substantial follower count, subsequently making a bulk purchase. Although the Cash App provides this service, it is crucial to discern between genuine and counterfeit items. If you find yourself in search of counterfeit products such as a Rolex, a Louis Vuitton item, or a Louis Vuitton bag, there are two viable approaches to consider.\n\n \nhttps://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nWhy you need to buy verified Cash App accounts personal or business?\nThe Cash App is a versatile digital wallet enabling seamless money transfers among its users. However, it presents a concern as it facilitates transfer to both verified and unverified individuals.\n\nTo address this, the Cash App offers the option to become a verified user, which unlocks a range of advantages. Verified users can enjoy perks such as express payment, immediate issue resolution, and a generous interest-free period of up to two weeks. With its user-friendly interface and enhanced capabilities, the Cash App caters to the needs of a wide audience, ensuring convenient and secure digital transactions for all.\n\nIf you’re a business person seeking additional funds to expand your business, we have a solution for you. Payroll management can often be a challenging task, regardless of whether you’re a small family-run business or a large corporation. How To Buy Verified Cash App Accounts.\n\nImproper payment practices can lead to potential issues with your employees, as they could report you to the government. However, worry not, as we offer a reliable and efficient way to ensure proper payroll management, avoiding any potential complications. Our services provide you with the funds you need without compromising your reputation or legal standing. With our assistance, you can focus on growing your business while maintaining a professional and compliant relationship with your employees. Purchase Verified Cash App Accounts.\n\nA Cash App has emerged as a leading peer-to-peer payment method, catering to a wide range of users. With its seamless functionality, individuals can effortlessly send and receive cash in a matter of seconds, bypassing the need for a traditional bank account or social security number. Buy verified cash app account.\n\nhttps://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nThis accessibility makes it particularly appealing to millennials, addressing a common challenge they face in accessing physical currency. As a result, ACash App has established itself as a preferred choice among diverse audiences, enabling swift and hassle-free transactions for everyone. Purchase Verified Cash App Accounts.\n\n https://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nHow to verify Cash App accounts\nTo ensure the verification of your Cash App account, it is essential to securely store all your required documents in your account. This process includes accurately supplying your date of birth and verifying the US or UK phone number linked to your Cash App account.\n\nAs part of the verification process, you will be asked to submit accurate personal details such as your date of birth, the last four digits of your SSN, and your email address. If additional information is requested by the Cash App community to validate your account, be prepared to provide it promptly. Upon successful verification, you will gain full access to managing your account balance, as well as sending and receiving funds seamlessly. Buy verified cash app account.\n\n \n\nHow cash used for international transaction?\nExperience the seamless convenience of this innovative platform that simplifies money transfers to the level of sending a text message. It effortlessly connects users within the familiar confines of their respective currency regions, primarily in the United States and the United Kingdom.\n\nNo matter if you’re a freelancer seeking to diversify your clientele or a small business eager to enhance market presence, this solution caters to your financial needs efficiently and securely. Embrace a world of unlimited possibilities while staying connected to your currency domain. Buy verified cash app account.\n\nUnderstanding the currency capabilities of your selected payment application is essential in today’s digital landscape, where versatile financial tools are increasingly sought after. In this era of rapid technological advancements, being well-informed about platforms such as Cash App is crucial.\n\nAs we progress into the digital age, the significance of keeping abreast of such services becomes more pronounced, emphasizing the necessity of staying updated with the evolving financial trends and options available. Buy verified cash app account.\n\nOffers and advantage to buy cash app accounts cheap?\nWith Cash App, the possibilities are endless, offering numerous advantages in online marketing, cryptocurrency trading, and mobile banking while ensuring high security. As a top creator of Cash App accounts, our team possesses unparalleled expertise in navigating the platform.\n\nWe deliver accounts with maximum security and unwavering loyalty at competitive prices unmatched by other agencies. Rest assured, you can trust our services without hesitation, as we prioritize your peace of mind and satisfaction above all else.\n\nEnhance your business operations effortlessly by utilizing the Cash App e-wallet for seamless payment processing, money transfers, and various other essential tasks. Amidst a myriad of transaction platforms in existence today, the Cash App e-wallet stands out as a premier choice, offering users a multitude of functions to streamline their financial activities effectively. Buy verified cash app account.\n\nTrustbizs.com stands by the Cash App’s superiority and recommends acquiring your Cash App accounts from this trusted source to optimize your business potential.\n\nHow Customizable are the Payment Options on Cash App for Businesses?\nDiscover the flexible payment options available to businesses on Cash App, enabling a range of customization features to streamline transactions. Business users have the ability to adjust transaction amounts, incorporate tipping options, and leverage robust reporting tools for enhanced financial management.\n\nExplore trustbizs.com to acquire verified Cash App accounts with LD backup at a competitive price, ensuring a secure and efficient payment solution for your business needs. Buy verified cash app account.\n\nDiscover Cash App, an innovative platform ideal for small business owners and entrepreneurs aiming to simplify their financial operations. With its intuitive interface, Cash App empowers businesses to seamlessly receive payments and effectively oversee their finances. Emphasizing customization, this app accommodates a variety of business requirements and preferences, making it a versatile tool for all.\n\nWhere To Buy Verified Cash App Accounts\nWhen considering purchasing a verified Cash App account, it is imperative to carefully scrutinize the seller’s pricing and payment methods. Look for pricing that aligns with the market value, ensuring transparency and legitimacy. Buy verified cash app account.\n\nEqually important is the need to opt for sellers who provide secure payment channels to safeguard your financial data. Trust your intuition; skepticism towards deals that appear overly advantageous or sellers who raise red flags is warranted. It is always wise to prioritize caution and explore alternative avenues if uncertainties arise.\n\nThe Importance Of Verified Cash App Accounts\nIn today’s digital age, the significance of verified Cash App accounts cannot be overstated, as they serve as a cornerstone for secure and trustworthy online transactions.\n\nBy acquiring verified Cash App accounts, users not only establish credibility but also instill the confidence required to participate in financial endeavors with peace of mind, thus solidifying its status as an indispensable asset for individuals navigating the digital marketplace.\n\nWhen considering purchasing a verified Cash App account, it is imperative to carefully scrutinize the seller’s pricing and payment methods. Look for pricing that aligns with the market value, ensuring transparency and legitimacy. Buy verified cash app account.\n\nEqually important is the need to opt for sellers who provide secure payment channels to safeguard your financial data. Trust your intuition; skepticism towards deals that appear overly advantageous or sellers who raise red flags is warranted. It is always wise to prioritize caution and explore alternative avenues if uncertainties arise.\n\nConclusion\nEnhance your online financial transactions with verified Cash App accounts, a secure and convenient option for all individuals. By purchasing these accounts, you can access exclusive features, benefit from higher transaction limits, and enjoy enhanced protection against fraudulent activities. Streamline your financial interactions and experience peace of mind knowing your transactions are secure and efficient with verified Cash App accounts.\nhttps://dmhelpshop.com/product/buy-verified-cash-app-account/\n\nChoose a trusted provider when acquiring accounts to guarantee legitimacy and reliability. In an era where Cash App is increasingly favored for financial transactions, possessing a verified account offers users peace of mind and ease in managing their finances. Make informed decisions to safeguard your financial assets and streamline your personal transactions effectively.\n\nContact Us / 24 Hours Reply\nTelegram:dmhelpshop\nWhatsApp: +1 (980) 277-2786\nSkype:dmhelpshop\nEmail:dmhelpshop@gmail.com\n\n" | agduvejwhis180 | |
1,873,252 | La Criptografia en l'Era de la Computació Quàntica i de la IA | En el món de la ciberseguretat, la irrupció de la computació quàntica suposa un abans i un després,... | 0 | 2024-06-01T20:11:07 | https://dev.to/gcjordi/la-criptografia-en-lera-de-la-computacio-quantica-i-de-la-ia-40if | quantum, cracking, encryption | En el món de la ciberseguretat, la irrupció de la computació quàntica suposa un abans i un després, especialment pel que fa als sistemes de xifratge actuals.
Un dels temes més candents és la capacitat potencial dels ordinadors quàntics per trencar els xifrats que avui en dia considerem segurs. Aquest article se centra en els fonaments del projecte "Quantum Cracking Encryption" disponible a [GitHub](https://github.com/gcjordi/quantum_cracking_encryption) i com aquest es relaciona amb la ruptura dels xifrats actuals i les mesures de protecció per a l'era post-quàntica.
**L'Algorisme de Shor i la seva Aplicació**
El repositori "Quantum Cracking Encryption" implementa l'algorisme de Shor, desenvolupat per [Peter Shor](https://en.wikipedia.org/wiki/Peter_Shor) el 1994. Aquest algorisme demostra que un ordinador quàntic és capaç de factoritzar nombres enters en temps polinòmic, una tasca que és exponencialment difícil per als ordinadors clàssics. Això és particularment rellevant per a la criptografia [RSA](https://arxiv.org/pdf/2308.02785), que basa la seva seguretat en la dificultat de factoritzar grans nombres primers.
Mitjançant l'ús de [Qiskit](https://www.ibm.com/quantum/qiskit), una eina desenvolupada per IBM per a la programació quàntica, aquest projecte permet als usuaris crear circuits quàntics capaços de realitzar factoritzacions utilitzant l'algorisme de Shor.
El repositori inclou notebooks de Jupyter que il·lustren com dissenyar i executar aquests circuits, proporcionant una comprensió pràctica de com un ordinador quàntic podria comprometre la seguretat de RSA.
**Implicacions per a la Criptografia Actual**
La capacitat de factoritzar nombres grans en temps raonable significaria que qualsevol clau RSA podria ser trencada, ja que la seguretat de RSA depèn directament de la dificultat de la factorització. Això no només afecta a RSA, sinó també a altres sistemes de xifratge que depenen de problemes matemàtics que es consideren difícils de resoldre per a ordinadors clàssics.
**Protecció per a l'Era Post-Quàntica**
Davant d'aquesta amenaça, la comunitat de ciberseguretat està desenvolupant nous mètodes de xifratge resistents a la computació quàntica, coneguts com a criptografia post-quàntica. Aquests mètodes es basen en problemes matemàtics que es creu que són difícils tant per a ordinadors clàssics com per a quàntics. Alguns dels algorismes en desenvolupament inclouen:
Criptografia basat en reticulats: Utilitza la complexitat de problemes geomètrics en espais multidimensionals.
Codi corrector d'errors: Aplica conceptes de teoria de codis per a crear xifrats.
Funcions de hash: Empra funcions matemàtiques que comprimeixen dades en valors més petits i no invertibles.
**La Influència de la IA**
La intel·ligència artificial (IA) també està jugant un paper important en aquest camp. Els algoritmes d'IA poden optimitzar el procés de descobriment de vulnerabilitats en els sistemes de xifratge actuals i en el disseny de nous algoritmes de xifratge resistents a la computació quàntica. En combinació amb la computació quàntica, la IA podria accelerar la ruptura de xifrats existents i alhora desenvolupar sistemes de seguretat més robustos per a la era post-quàntica.
**Conclusió**
La computació quàntica suposa un repte significatiu per a la seguretat de les dades xifrades amb mètodes tradicionals com RSA. Projectes com "Quantum Cracking Encryption" proporcionen una visió pràctica de com aquests reptes poden materialitzar-se.
Al mateix temps, la investigació en criptografia post-quàntica és cabdal per assegurar la seguretat de les comunicacions i la informació en un futur (no gaire llunyà) dominat per la computació quàntica. Adaptar-se a aquests nous paradigmes serà essencial per mantenir la integritat i la confidencialitat de les dades en els pròxims anys.
La **_combinació de la IA i la computació quàntica_** pot tant amenaçar com reforçar els sistemes de seguretat, depenent de com es gestionin aquestes tecnologies.
[Jordi G. Castillón](https://jordigarcia.eu/) | gcjordi |
1,873,251 | A Comprehensive Guide to IT Asset Disposition | In the modernized technological world of 2024, companies need to upgrade themselves in taking further... | 0 | 2024-06-01T20:09:01 | https://dev.to/liong/a-comprehensive-guide-to-it-asset-disposition-2gin | it, disposal, malaysia, kualalumpur | In the modernized technological world of 2024, companies need to upgrade themselves in taking further steps in IT Asset Disposal. This a stupid mistake we all make while doing the disposal of IT stuff. We forget that this stuff does not only have information but also every sensitive info of the people. Am I right? Here at this point, rather than just doing a dump of outdated tools or equipment, you just need to follow a proper process of IT disposition. Now here is the time when the IT asset disposition (ITAD) comes into play.
## What is ITAD?
ITAD is called the IT Asset Disposition. This consists of several steps that work to manage and dispose of the lf outdated or unused IT equipment or stuff. This covers your hardware setup (servers, laptops, and mobiles) along with software licenses and the data on those assets.
Using a well-defined ITAD process is important for several reasons:
1. **Data Security:** The assets have the sensitive information of many people or it can be even about companies too, so this does not need to be disposed of as throwing it away, NO! Wrong disposal can cause many problems like data leaks or something like that which can affect you in the future.
2. **Environmental Compliance:** This includes that while doing the disposal you must be taking care and working without impacting the environment. The asset disposal contains E-waste, the discarded electronic and electrical equipment, which poses an important environmental threat. The best ITAD is all about that it confirms keeping with environmental regulations and promotes sustainability.
3. **Financial Rescue:** You need to hold onto the old assets because when you recycle, restore, and refurbish these assets, in the end, it can give you much profit and this can automatically help you to get the cost of new equipment.
4. **Risk Control:** When you do not do IT disposal properly, this will automatically lead to more problems or issues like company data being revealed or data breaches.
## This comprehensive guide delves into the key steps and considerations involved in effective ITAD:
Additionally, to avoid such problems, mistakes, or issues in the future then you must know that this matter is solved when you follow these key steps. The key step is listed in the following.:
## 1.Inventory and Assessment:
Firstly you need to prepare to create a checklist of all the [IT asset disposal](https://ithubtechnologies.com/it-hardware-inventory-management/?utm_source=dev.to&utm_campaign=itassetdisposal&utm_id=Offpageseo+2024). This list will help you initially. This includes the following:
- **Hardware:** Servers, desktops, laptops, tablets, mobile devices, printers, etc.
- **Software:** You need licenses for operating systems and other kinds of software.
- **Data:** The type and sensitivity of data stored on the assets.
This checklist helps pick the best disposal method for each asset based on its condition, functionality, and data security requirements.
## 2. Data Erasure and Security:
Secondly here comes data security which is the main part of the ITAD process. When you are starting to dispose of IT asset equipment or stuff disposal, you need to be sure that all the content or sensitive information has been removed. This information or sensitive stuff can be removed by using legal data removal methods. Data security makes sure that it does not get into the wrong hands. If somehow it gets into the wrong hands then, this security will protect your information or data.
The following methods which are used by the certified data security depend on the storage media itself:
- **Overwriting:** When you are excessively overwriting the data with random characters make sure that it cannot be recovered.
- **Degaussing:** This method is all about magnetic field use, in which the magnetic fields are used to permanently eliminate or remove the data from hard drives.
- **Physical defeat:** In very extreme cases sometimes in hacker situations, when you physically destroy the IT Asset make sure to remove the data forever permanently.
## 3. Environmental Compliance:
Thirdly it is the Electronic waste (e-waste) here that plays a major role in being a main hazard for our environment. It is very important to follow the local or movement rules of regularly doing the e-waste disposal stuff.
Here are some key carefulness we should take to avoid e-waste:
- **E-waste recyclers:** You should partner with certified recyclers as they follow strict rules and regulations of the environment while doing disposal.
- **Documentation:** You should also manage and maintain every documentation or paper of the disposal process and this will make sure that there is a complete chain of custody of e-waste.
## 4. Asset Reuse and Resale:
In the fourth step, you must think that every asset has to be disposed off. I'll give you the answer, the thing is that not all IT assets are disposed of as soon as possible but we need to make sure to carefully check their value. Now here, consider the following options for maximizing the value of your assets:
- **Internal Reuse:** Imagine that your IT assets can be repurposed within your organization for other departments or projects.
- **Refurbishment:** The restoration is also done when an old asset is renewed or outdated and converted to a working one, and then it can be sold again.
- **Resale:** You can also sell used IT assets or equipment through online marketplaces or any specialized IT asset remarketing companies.
## 5. Choosing an ITAD Provider:
While choosing any ITAD provider, you must be cautious and must partner with an expert ITAD service provider. This can help you to be assured that IT asset disposal is done completely. For complex ITAD projects, partnering with a reputable ITAD service provider can be beneficial. These providers offer expertise in:
1. Secure data removal
2. Environment Laws
3. Check asset cost and resale
4. Transportation (Pick and Drop)
### 6. Documentation and Reporting:
At last, it is the most important part of the ITAD process is the documentation part which includes the following:
1. List of disposed assets
2. Data removal certificates
3. Recycling certificates
4. Custody of the records
5. Cost, resale, or refurbishment
## Conclusion:
According to the above-highlighted points, it can be concluded that when we follow such detailed steps of ITAD, then we can protect ourselves or even our companies from such kinds of issues. You need to follow the instructions clearly and don't worry I have your back to save you.
| liong |
1,873,250 | Oluwanifemi's Day 1 of Forever | The people I admire the most used to be healthcare professionals, like my eye doctor. Once, I spent a... | 0 | 2024-06-01T20:00:25 | https://dev.to/nifedara/oluwanifemis-day-1-of-forever-536l | opensource, outreachy, osm, hotosm | The people I admire the most used to be healthcare professionals, like my eye doctor. Once, I spent a good time telling him how he was making lives better. I mean he helped me see better. That was noble to me.
Now you know my new set of favourite people? They are the ones who have chosen to dedicate their time to improving people's lives with open software. They come in different forms: open-source contributor/volunteer, maintainer, committer (I just learnt of this, courtesy of [Open Source Guide](https://opensource.guide/leadership-and-governance/)).
These people come together with the shared goal to build and improve software whose source code is available to everyone. As opposed to private proprietary software.
> _Read more on Open source vs Proprietary software [here](https://www.geeksforgeeks.org/difference-between-open-source-software-and-proprietary-software/)._
---
It is with joy that I share that I will get my first experience contributing to open-source for the next 3 months. Through the Outreachy internship, I was selected to work with HOTOSM from May to August 2024.
[Outreachy](https://www.outreachy.org/apply/) is a paid internship that supports underrepresented individuals in tech to contribute to open-source projects.
And [HOTOSM](https://www.hotosm.org/what-we-do.html), the organisation I will be working with uses open mapping for humanitarian purposes, providing map data to aid in disaster management, community development and the achievement of Sustainable Development Goals.
I have had a great first week with HOTOSM. I have received warm welcomes from my mentors, fellow intern and our coordinator.
{% embed https://giphy.com/gifs/dccmakingtheteam-cmt-dallas-cowboys-cheerleaders-dcc-making-the-team-l3vRfAuz4tU2Svalq %}
This explains how I felt when I received the news that I was selected. I had put in a lot of effort during the contribution phase, but there were many contributors, so I wasn't sure about the outcome. I am incredibly grateful to have been selected, and I'm also thankful for going through the contribution phase because it taught me to concentrate on tasks and get things done, no matter how many people were working towards the same goal.
---
This is day 1 of forever making an impact through my work. I get to work on projects that will directly impact lives. I have long envisioned this and I am excited to begin.
My name is Oluwanifemi, and I am now among my favourite group of people 😊.
My core values are compassion and optimism.
I am driven by compassion for those in unfavourable conditions.
I also value optimism. I hope all things, I believe all things.
Some people describe me sometimes as one who puts their head in the clouds 😂 (I must add though that it is not to the point of being counterproductive. Just enough to help me dream lofty dreams).
> _Writing requires so much effort, so I will stop here for now. Stay tuned for more updates about my internship as I have so many things to share._
| nifedara |
1,873,249 | Vrije tijd | Hallo, kunt u mij een leuke service aanbevelen om mijn vrije tijd te verdoen? | 0 | 2024-06-01T19:49:36 | https://dev.to/alexseen12/jacktop-38gm |
Hallo, kunt u mij een leuke service aanbevelen om mijn vrije tijd te verdoen? | alexseen12 | |
1,873,247 | TLDR; Suspense in react-query | In React Query, Suspense is a way to handle loading states for asynchronous data fetching. It... | 0 | 2024-06-01T19:48:41 | https://dev.to/thechaudhrysab/tldr-suspense-in-react-query-5f4c | programming, react, reactnative, reactquery | In React Query, Suspense is a way to handle loading states for asynchronous data fetching. It essentially lets your components "pause" until the data they need is available. For example if your data is bing fetched react loads a temporary component instead until the data becomes available.
> Note: Suspense requires React 18 or later.
## Without Suspense:
- You typically use a state variable (e.g., `isLoading`) to indicate if data is being fetched.
- You conditionally render loading indicators while the data is being fetched.
- This can lead to a lot of conditional logic and potentially messy code.
## With Suspense:
- Wrap your component in a Suspense boundary: This signals to React that your component might need to wait for data.
- Use `useQuery`: This hook fetches data asynchronously and provides information about the data fetching state (_loading_, _error_, _data_).
- React Query throws a promise: When data is being fetched, useQuery internally throws a promise. This "**suspends**" rendering.
- Suspense boundary catches the promise: The Suspense boundary catches the promise thrown by `useQuery` and renders a fallback component (e.g., a loading indicator) while the data is being fetched.
- Data arrives and rendering resumes: Once the promise resolves with the data, React continues rendering your component with the actual data.
### Benefits of Suspense:
- Cleaner code: You avoid repetitive conditional logic for loading states.
- Improved user experience: Users see a clear loading indicator while data is being fetched.
### React Query and Suspense work together seamlessly:
- React Query manages data fetching and provides the "suspending" behavior.
- You can use Suspense boundaries to handle loading states in a cleaner way.
<hr />
**Code example:**
https://tanstack.com/query/v5/docs/framework/react/examples/suspense
| thechaudhrysab |
1,873,238 | EP-1: WTF is Spring Boot? | The Man, The Myth, Not Thala, But Spring Boot What make a java developer powerful?... | 0 | 2024-06-01T19:43:50 | https://dev.to/0x4e43/ep-1-wtf-is-spring-boot-a31 | java, springboot, beginners, webdev | ## The Man, The Myth, Not Thala, But Spring Boot
What make a java developer powerful? Obviously knowing how to write REST API. Having ability to talk to server by writing mere alphabets in your code editor is not less than having any superpower. In the world of Java, Its not the REDBULL which gives you wing, Its **Spring Boot** which gives you wings and let you fly high.
## How to have super power
No individual born with power, people have to acquire it. If you want to have the super power of talking to server you need to go to a place in internet [start.spring.io](https://start.spring.io/). The virtual **pornhub ** for java developers.
**What it gives**
- Boilerplate starter code for creating a basic spring boot application.
- Standard project structure, Ensures your code can suck but not your project structure
- Nothing else
If you hit on the GENERATE button one zip folder will magically get downloaded.
Unzip It, Open it with some of the world class IDE like Intellij Idea or VS code and hit on the Play button.
DONE, You have created your first Spring boot project.
Lets DIVE Deep on next Episode.
Happy Booting.
| 0x4e43 |
1,863,041 | Teach | Does anyone teach Javascript, React, and React Native? | 0 | 2024-05-23T16:48:41 | https://dev.to/otis_lewis_8e92b5b90551a5/teach-2eoh | Does anyone teach Javascript, React, and React Native? | otis_lewis_8e92b5b90551a5 | |
1,873,242 | Building Zerocalc, part I - rustc lexer and a lexer in rust | After reading The Rust Programming Language book and implementing a few exercises, it's time to write... | 27,824 | 2024-06-01T19:39:26 | https://dev.to/michal1024/building-zerocalc-part-i-rustc-lexer-and-a-lexer-in-rust-3ipf | rust, programming | After reading *The Rust Programming Language* book and implementing a few exercises, it's time to write a real application. I want to write something I can use myself, which is not yet another "Todo" list. So I decided to build... yet another calculator!
The calculators I enjoy using are the notebook-like ones such as [Insect](https://github.com/sharkdp/insect?tab=readme-ov-file) or [Parsify](https://parsify.app/). I found this to be a good project idea for learning a new programming language. Building such a calculator requires a parser implementation and UI implementation. Once the basic calculator is done, enhancements and technology exploration are endless possibilities. Consider a currency conversion feature that takes real-time data from some online currency exchange service. Implementing it would involve REST API calls, async code, and/or threading.
To drive our implementation, we will use this very simple expression:
`123+4`
The first thing our calculator needs to do is to parse this expression. A common way to do it is to break parsing into two phases:
* Processing text into a stream of tokens
* Building a graph representing the expression (the abstract syntax tree).
In this post, we will focus on tokenization. There are many ways to do tokenization, including using regular expressions or generating tokenizer code with generators such as [flex](https://github.com/westes/flex). But what if we check how `rustc`'s parser does it?
Rustc uses straightforward token representation:
```rust
pub struct Token {
kind: TokenKind,
len: usize
}
```
Note there is no token value or token position stored. We'll later see how the parser can retrieve the token's value using just the length of the token.
`TokenKind` identifies the type of token. Rustc defines 39 token kinds. For our simple expression, we need much less, however, the general idea remains the same:
```rust
pub enum TokenKind {
/// 123, 0.123, "abc" etc.
Literal(LiteralKind),
/// +
Add,
/// not recognized
Unknown,
/// end of input
Eof,
}
```
Some token types need additional parameters, for example, in the case of literal, we need to know whether this is an integer, floating point number, string, etc. To parse our sample expression we need at least integers:
```rust
pub enum LiteralKind {
Int,
}
```
Actual rust literals are more complex: an integer needs information about its base (for binary, decimal, octal, or hex numbers) and the length of its suffix so that `12u32` can be properly recognized as a 32-bit unsigned integer. All this information is stored in the parameters of the literal enum.
Tokenization is done by a structure called `Cursor` which also is very minimalistic:
```rust
pub struct Cursor<'a> {
chars: Chars<'a>,
len_remaining: usize,
}
impl Cursor<'_> {
fn new(input: &str) -> Cursor<'_> {
Cursor {
chars: input.chars(),
len_remaining: input.len(),
}
}
//...
```
The `Chars` type from the Rust standard library implements the `Iterator` trait over a `str` slice. `Cursor` uses this iterator to advance over the input string with the `bump` method. It also uses it to calculate the length of the token; the length of the token is a difference between the previous length of input and the remaining length of input. This calculation is done by the `pos_within_token` method. Once a token is parsed, the remaining length is updated (`reset_pos_within_token`).
```rust
// impl Cursor continued
fn new(input: &str) -> Cursor<'_> {
Cursor {
chars: input.chars(),
len_remaining: input.len(),
}
}
fn bump(&mut self) -> Option<char> {
self.chars.next()
}
fn pos_within_token(&mut self) -> usize {
self.len_remaining - self.chars.as_str().len()
}
fn reset_pos_within_token(&mut self) {
self.len_remaining = self.chars.as_str().len();
}
}
```
Let's see how this may work for our input expression `123+4`. The initial length is 5. If we stop at `+`, the remaining length will be 2, so `pos_within_token` will return 3 which is the actual length of `123` literal.
Before we start tokenizing we need one more utility - the ability to sneak preview the next character before we advance the cursor. This helps to determine the token kind. For example, if we see `/` it's good to know if what follows is `/` (regular comment), `//` (doc comment), or `*` (block comment).
```rust
// impl Cursor continued
fn first(&self) -> char {
self.chars.clone().next().unwrap_or(EOF_CHAR)
}
fn second(&self) -> char {
let mut iter = self.chars.clone();
iter.next();
iter.next().unwrap_or(EOF_CHAR)
}
fn third(&self) -> char {
let mut iter = self.chars.clone();
iter.next();
iter.next();
iter.next().unwrap_or(EOF_CHAR)
}
```
That looks like a lot, but apparently, cloning the cursor and advancing it optimizes very well; Rust focuses on operating on a stack with types of known size which I guess makes generating optimized code easier.
Now let's tokenize our expression:
```rust
impl Cursor<'_> {
fn advance_token(&mut self) -> Token {
let char = match self.bump() {
Some(c) => c,
None => return Token::new(TokenKind::Eof, 0),
};
let token_kind = match char {
'0'..='9' => {
let literal_kind = self.number();
TokenKind::Literal(literal_kind)
}
'+' => TokenKind::Add,
_ => TokenKind::Unknown,
};
let token = Token::new(token_kind, self.pos_within_token());
self.reset_pos_within_token();
token
}
```
We start with reading the next character (and advancing the cursor at the same time). If that operation does not return value, it means we reached the end of input so we need to return the final `Eof` token. Then we need to decide what kind of token we are parsing. That may require looking ahead with one of `first/second/third` methods as in the case of comments. For our simple `123+4` expression, it's enough if we check if we deal with a digit or a `+` sign. If we face something surprising, we return `Unknown` letting client code decide what to do.
Parsing `Int` literal in our example is very simple:
```rust
fn number(&mut self) -> LiteralKind {
loop {
match self.first() {
'0'..='9' => {
self.bump();
}
_ => break,
}
}
LiteralKind::Int
}
```
Actual Rust literals are much more complex - different string types, different number representations, etc. Rustc's lexer advances over input and matches received characters against patterns, building an understanding of what type of literal or other token kind it deals with. This method of top-down parsing is called *Recursive Descent Parsing*.
To make our tokenizer easier to use, we can wrap `Cursor` into the `Iterator` trait. There is a nice utility in Rust std library to do this, namely the `iter::from_fn`:
```rust
pub fn tokenize(input: &str) -> impl Iterator<Item = Token> + '_ {
let mut cursor = Cursor::new(input);
std::iter::from_fn(move || {
let token = cursor.advance_token();
if token.kind != TokenKind::Eof { Some(token) } else { None }
})
}
```
How one uses this tokenizer? Let's write a test to show it:
```rust
#[test]
fn test_cursor() {
let input = "123+4";
let mut pos = 0;
let mut cursor = tokenize(&input);
let Token { kind, len } = cursor.next().unwrap();
let token_val = &input[pos..pos + len];
assert_eq!(TokenKind::Literal(LiteralKind::Int), kind);
assert_eq!(token_val, "123");
pos = pos + len;
let Token { kind, len } = cursor.next().unwrap();
let token_val = &input[pos..pos + len];
assert_eq!(TokenKind::Add, kind);
assert_eq!(token_val, "+");
pos = pos + len;
let Token { kind, len } = cursor.next().unwrap();
let token_val = &input[pos..pos + len];
assert_eq!(TokenKind::Literal(LiteralKind::Int), kind);
assert_eq!(token_val, "4");
assert_eq!(None, cursor.next());
}
```
Client code must track the position of the token within the input string. This allows to read the actual value of the token directly from the input string and tokenization does not require copying any of the input string.
And that is it! The rest of the rustc tokenizer code is mostly heuristics that allow the tokenizer to identify tokens.
My first job as a software engineer was in a software quality company where I worked on a C++ code analyzer. We've been working with a parser that was generated using bison/flex-like tools. Since C++ is a context-sensitive language, it cannot be expressed as a simple LL(k) grammar. As a result, our parser was a stack of patches and hacks on top of auto-generated code and a real nightmare to work with. After a while, we switched to a third-party parser which was implemented as a recursive descent parser. I enjoy the clarity and flexibility of this approach to parsing code.
Sources:
1. https://github.com/rust-lang/rust/tree/master/compiler/rustc_lexer
2. https://en.wikipedia.org/wiki/Recursive_descent_parser
3. https://doc.rust-lang.org/stable/std/index.html | michal1024 |
1,872,875 | I'm New To Flutter. | "Welcome to the world of Flutter!" If you're reading this, chances are you're curious... | 0 | 2024-06-01T19:30:00 | https://dev.to/lyzab/im-new-to-flutter-3j7g | codenewbie, flutter, developer, learning |
## **"Welcome to the world of Flutter!"**
If you're reading this, chances are you're curious about building mobile apps with this popular framework. Maybe you're even an expert at this. I welcome you, either ways, to this incredibly powerful and flexible tool for building cross-platform apps.
_"Flutter is a tool for building mobile apps, like the ones you use on your phone. Imagine you want to build a house, but instead of using different materials for the walls, roof, and floors, you use a special kind of LEGO block that can be used for everything! That's basically what Flutter does, but instead of LEGO blocks, it uses a single codebase to build apps for both Android and iOS systems. This means developers can create apps more efficiently and quickly, without having to start from scratch for each platform. It's like a magic LEGO block for mobile apps!"_
This was probably the most basic and fun way I've seen Flutter described.
> Flutter, the open-source mobile app development framework created by Google, has revolutionized the way we build cross-platform applications.
> Flutter uses a modern language called Dart and a framework that focuses on declarative programming to help developers build fast and beautiful apps that work smoothly on both Android and iOS devices.
You most likely knew all these already, though.
What I'm actually going to be talking about in this article is how I transitioned from the Web aspect of programming into Mobile Development. So yeah, it's not a technical write-up.
Grab a cup of coffee or whatever , get comfortable, and join me on this thrilling journey about tribulations, and the lessons I've learned along the way. Buckle up, friend, as we dive into the world of coding!
Few years ago, I started out into programming. I was excited at first, you know, at the prospect of writing "codes". Of course, it was simple HTML and CSS. I loved styling, I created numerous simple projects, using those languages. I even created a clone of the YouTube homepage, with no functionalities whatsoever 😂. At that time, I was almost never doing anything else.
You can probably predict that when I got to JavaScript, I ran 🤣.
To think that it was only vanilla js. That was the first time, though. Okay...before then, I actually started out with Python, learnt the basics. It was a very good [4-hour YouTube video](https://www.youtube.com/watch?v=rfscVS0vtbw) on Python programming basics.
So, like I was saying, the first time, I had a hard time understanding concepts like destructuring assignment in js, even the syntax of functions.
I remember applying for trainings, to understand js. Some of them weren't free, of course. **I asked for help from friends,** read materials to aid my understanding.
The second time I started all over, though, everything started to make sense. I loved js. If you read [my previous article](https://dev.to/lyzab/programming-newbie-beginner-tips-1d03), you'd probably remember me mentioning I was addicted to solving algorithms on Codewars and HackerRank. It was mostly [Codewars](https://www.codewars.com), though. It kept me up so late into the night. I can recall not sleeping a wink, this particular day, until about 6 a.m, because I was solving algorithms 😂😂.
All of these were after almost a year of trying to escape programming.
Sometime later, through the help of a friend, I got someone to mentor me in React js. For some reason, it still didn't resonate with me. At a point, I began to question if I was actually interested n programming. Lots of conversations in my head, questions on my mind. I resumed back to school and almost totally forgot to code.
I struggled with learning React JS, despite having a mentor to guide me. My difficulties led to self-doubt, and I wondered if programming was truly my passion. I had many inner conversations and questions, which ultimately led me to put coding on hold when I returned to school 🙂. I felt like I wasn't cut out for programming.
**.
..
...
....
.....**
Later, I realized that setbacks and doubts are an inevitable part of growth. And so, right now, I'm taking another shot at coding, but this time with a fresh approach. Something a bit different.
You see, it's okay to take a break for a while, but never stop doing something because you think it's too difficult. I'm now on a mission to excel in mobile development, and I'm going to give it my best shot.
I'll talk about my motivation to learn Flutter some other time, but I'll wrap up here for now.
Thanks for reading!!😁😁
I'm open to connecting with you on [LinkedIn](www.linkedin.com/in/elizabeth-ajileye-78b2a422b).
| lyzab |
1,873,244 | Buy Xanax Online - Say Goodbye to Stress and Tension | Click To buy:https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T19:20:10 | https://dev.to/shaizi/buy-xanax-online-say-goodbye-to-stress-and-tension-5e46 | Click To buy:https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| shaizi | |
1,873,243 | Buy Xanax Online - Relaxation and Calmness Awaits | Click To buy:https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T19:19:38 | https://dev.to/shaizi/buy-xanax-online-relaxation-and-calmness-awaits-jpo | Click To buy:https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| shaizi | |
1,873,241 | How I made a drag-and-drop file uploader with Vue3 and Firebase | There is shared responsibility between the client and the server when handling features such as... | 0 | 2024-06-01T19:16:08 | https://dev.to/pentektimi/how-i-made-a-drag-and-drop-file-uploader-with-vue3-and-firebase-1697 | There is shared responsibility between the client and the server when handling features such as uploading files. The client takes care of transferring the file to the server and providing a way to access the file. The server takes care of validating the upload, storing the file, file permissions, and creating the API for the client to send the file.
I started out by building the component where users will be able to drop the files. After I was done with the HTML template I had to find a way to ‘pay attention’ to drag and drop actions made by the user. Luckily, there are Javascript event listeners for drag and drop events such as: drag, dragstart, dragend, dragover, dragenter, dragleave, drop. I added these event listeners to the div tag that acted as the ‘drop zone’, however, by default most browsers redirect the user away from the app when a file is dropped. To avoid this behaviour I used event modifiers, which allowed me to handle what happens when a file is dropped. The event modifiers I added were ‘prevent’ and ‘stop’. Once the drop event fired I created an upload function where I handled most of the logic.
```Javascript
<div
class="w-full px-10 py-20 rounded text-center cursor-pointer border border-dashed border-gray-400 text-gray-400 transition duration-500 hover:text-white"
:class="{ 'bg-[#4EE4A2] border-[#4EE4A2] border-solid': is_dragover }"
@drag.prevent.stop=""
@dragstart.prevent.stop=""
@dragend.prevent.stop="is_dragover = false"
@dragover.prevent.stop="is_dragover = true"
@dragenter.prevent.stop="is_dragover = true"
@dragleave.prevent.stop="is_dragover = false"
@drop.prevent.stop="upload($event)"
>
```
The next step was to retrieve the file/s that the user uploaded. To do this, I needed access to the $event object. The event object refers to the argument added to the event handler function, and it contains information regarding the event that caused the given handler to be invoked. The event object contains a property called ‘dataTransfer’, which is an object that contains the information on the files transferred.
Once I had access to the uploaded files the next step was to transfer them to the Firebase storage. Since the event object provided me with the files in an object format (this was tricky as the object has numeric keys and it looked like an array), the first step I took was to convert them into an array so that I can loop through the array and send each file to Firebase. I converted the object into an array using the spread operator, and iterated through the array. For each file I added a validation to check whether the file’s mime type corresponds to what I was expecting to receive from the user. Validation can be performed both on the client and server side. For this particular project I was allowing only mp3 files to be sent to the server.
```Javascript
upload($event) {
this.is_dragover = false
// convert obj to array
const files = $event.dataTransfer ? [...$event.dataTransfer.files] : [...$event.target.files]
files.forEach((file) => {
if (file.type !== 'audio/mpeg') {
return
}
}
```
I initialised the Firebase storage and set up a reference to the main storage which basically represents the bucket url. Once I had reference to the main storage I also created a child reference to the folder holding the audio files just to keep everything clean. The last step was to actually upload the files to Firebase, and to achieve this I used a Firebase specific function called uploadBytesResumable(ref, data, metadata). I choose this function because it exposes progress updates, which helped me create progress bars for the uploads.
```Javascript
upload($event) {
this.is_dragover = false
// convert obj to array
const files = $event.dataTransfer ? [...$event.dataTransfer.files] : [...$event.target.files]
files.forEach((file) => {
if (file.type !== 'audio/mpeg') {
return
}
const storageReference = ref(storage)
const podcastRef = ref(storageReference, `/podcasts/${file.name}`)
const uploadTask = uploadBytesResumable(podcastRef, file)
}
```
This is roughly the logic behind how I managed to upload files to Firebase that came from a drag and drop event. I later added to the project animated progress bars, handled the responses from Firebase accordingly and stored the file data in Firebase database with additional fields such as who uploaded the audio file, the name of the file, genre, etc. Follow this link to see the full component logic: https://github.com/PentekTimi/podcast-listener/blob/master/src/components/AppUpload.vue
| pentektimi | |
1,862,974 | Selenium | Selenium is a widely-used tool for automating web browsers, essential for anyone involved in web... | 0 | 2024-05-23T14:48:47 | https://dev.to/vigneshpm/selenium-2cbl | Selenium is a widely-used tool for automating web browsers, essential for anyone involved in web development and testing. It allows users to write scripts that interact with web applications just as a human would, performing tasks such as clicking buttons, filling out forms, and navigating pages. This capability makes Selenium invaluable for testing web applications, ensuring they function correctly across different browsers and platforms.
One of the primary reasons to use Selenium for automation is its ability to handle repetitive tasks efficiently. For example, suppose a developer needs to test a login form. Manually entering the username and password and clicking the login button every time can be time-consuming and prone to errors. With Selenium, a script can be written to automate this process, performing the task quickly and accurately each time. This automation not only saves time but also ensures consistency in testing.
Selenium supports multiple programming languages, including Python, Java, C#, and JavaScript, which makes it accessible to a broad range of developers. This flexibility allows teams to write tests in the language they are most comfortable with, integrating seamlessly into their existing development workflows. Additionally, Selenium is compatible with various browsers like Chrome, Firefox, Safari, and Internet Explorer, which is crucial for cross-browser testing.
For example, a quality assurance (QA) engineer can use Selenium to write a test script that opens a web application in multiple browsers, checks that all elements are displayed correctly, and verifies that all functionalities, like form submissions and navigation links, work as expected. This automated testing ensures that users will have a consistent and error-free experience regardless of the browser they use. | vigneshpm | |
1,873,240 | Buy Xanax Online - Worldwide Shipping for Your Convenience | Click To buy:https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T19:14:03 | https://dev.to/mooray/buy-xanax-online-worldwide-shipping-for-your-convenience-1khc | Click To buy:https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| mooray | |
1,873,239 | Buy Xanax Online - Get 10% Off with Bitcoin Purchase | Click To buy:https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T19:13:33 | https://dev.to/mooray/buy-xanax-online-get-10-off-with-bitcoin-purchase-fl2 | Click To buy:https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| mooray | |
1,873,236 | LeetCode Meditations: Word Search II | Let's start with the description for Word Search II: Given an m x n board of characters and a list... | 26,418 | 2024-06-01T19:05:53 | https://rivea0.github.io/blog/leetcode-meditations-word-search-ii | computerscience, algorithms, typescript, javascript | Let's start with the description for [Word Search II](https://leetcode.com/problems/word-search-ii):
> Given an `m x n` `board` of characters and a list of strings `words`, return _all words on the board_.
>
> Each word must be constructed from letters of sequentially adjacent cells, where **adjacent cells** are horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.
For example:
<img src="https://assets.leetcode.com/uploads/2020/11/07/search1.jpg" alt="Example image 1" />
```
Input: board = [
['o', 'a', 'a', 'n'],
['e', 't', 'a', 'e'],
['i', 'h', 'k', 'r'],
['i', 'f', 'l', 'v'],
], words = ['oath', 'pea', 'eat', 'rain']
Output: ['eat', 'oath']
```
Or:
<img src="https://assets.leetcode.com/uploads/2020/11/07/search2.jpg" alt="Example image 2" />
```
Input: board = [
['a', 'b'],
['c', 'd']
], words = ['abcb']
Output: []
```
Also, our constraints are:
- `m == board.length`
- `n == board[i].length`
- `1 <= m, n <= 12`
- `board[i][j]` is a lowercase English letter.
- `1 <= words.length <= 3 * 10^4`
- `1 <= words[i].length <= 10`
- `words[i]` consists of lowercase English letters.
- All the strings of `words` are unique.
---
We've seen the first iteration of this problem where we needed to search for only one word.
It's easy to think that, well, we can just loop over the words this time, and return those that our board has. Simple as that.
For example, if you remember the `exist` function (which uses depth-first search) that [we implemented in the previous version of this problem](https://rivea0.github.io/blog/leetcode-meditations-word-search), you might think that it's easy to do this:
```ts
function findWords(board: string[][], words: string[]): string[] {
let result = [];
for (const word of words) {
if (exist(board, word)) {
result.push(word);
}
}
return result;
}
```
However, this is going to be a terrible approach with a runtime of probably {% katex inline %} O(\text{length of rows } * \text{length of columns } * 4^{\text{length of the word }} * \text{ number of words}) {% endkatex %}.
| Note |
| :-- |
| In `exist`, we [used](https://rivea0.github.io/blog/leetcode-meditations-word-search) depth-first search to look for the up, down, left and right directions — hence, {% katex inline %} 4^\text{length of the word} {% endkatex %}. |
If we try that, we'll treat ourselves a good old **Time Limit Exceeded** error in one of the test cases. So, we need to find another way to solve this problem — which means it's time to take a deep breath.
---
Instead of going through each word in `words` and looking for it in `board`, we can look through `board` first. If the character we're looking at is in `words`, then we'll continue searching through its directions until we find the complete word (or not).
Because we're doing a character lookup (or basically, a _prefix search_), [trie](https://rivea0.github.io/blog/leetcode-meditations-chapter-10-tries) is going to be an efficient choice of data structure here.
Let's start with creating our simple trie node which has `children`, and a flag `isEndOfWord` to mark it as the end of the word character:
```ts
class TrieNode {
public children: Map<string, TrieNode>;
public isEndOfWord: boolean;
constructor() {
this.children = new Map();
this.isEndOfWord = false;
}
}
```
Then, we'll create our trie, but for now, we'll only have an `addWord` method. This is exactly what we've seen for the last two problems, so it's easy:
```ts
class Trie {
public root: TrieNode;
constructor() {
this.root = new TrieNode();
}
addWord(word: string) {
let currentNode = this.root;
for (const char of word) {
if (!currentNode.children.has(char)) {
currentNode.children.set(char, new TrieNode());
}
currentNode = currentNode.children.get(char) as TrieNode;
}
currentNode.isEndOfWord = true;
}
}
```
Traversing each character in `word`, we add it to our trie, updating the current node (which starts as our root node, of course) as we go. Once we reach the last character, we mark it as the end of the word.
| Note |
| :-- |
| Similar to the previous problems, we're casting `currentNode.children.get(char)` as a `TrieNode`, because TypeScript thinks that it might be `undefined`. This is one of those times that we know more than the TS compiler, so we're using a [type assertion](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-assertions). <br> Alternatively, we could've also used a [non-null assertion operator](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#non-null-assertion-operator-postfix) that asserts values as non `null` or `undefined`, like this: <br> <br> `currentNode = currentNode.children.get(char)!;` |
Now, the first thing to do if we want to look up the words in our trie is... to add them to our trie, of course!
Inside the `findWords` function, we can do that easily:
```ts
let trie = new Trie();
for (const word of words) {
trie.addWord(word);
}
```
We'll also have a `result` array to add the words that are in `board`:
```ts
let result: string[] = [];
```
This array will be modified by the function that does the depth-first search, so that at the end of our main function `findWords`, we can just return it.
For each cell, we'll run a depth-first search _if that character is the start of a word in `words`_:
```ts
for (let i = 0; i < rowsLength; i++) {
for (let j = 0; j < colsLength; j++) {
if (trie.root.children.has(board[i][j])) {
dfs(i, j, trie.root.children.get(board[i][j]) as TrieNode, []);
}
}
}
```
So, if `board[i][j]` (which is the current character) is the first character of a word in `words`, we'll run `dfs`, passing it the arguments of the current row and column, as well as the next character (`trie.root.children.get(board[i][j])`). We'll also pass it an empty array to keep track of the path we're exploring.
Now let's look at the `dfs` function itself.
The first thing we need to do is to add the current character (the current cell) to our path, and mark it as "visited." We can mark it with an asterisk (`*`) to do that:
```ts
let currentChar = board[currentRow][currentCol];
path.push(currentChar);
board[currentRow][currentCol] = '*';
```
Now, if the current node we're looking at is the end character of a word, that means our `path` consists of all the letters of a word in `words`, so we can add it to `result` as a string. After that, we'll mark that node as _not the end of a word_, because in our next iterations, that node might not be the end character of another word:
```ts
if (currentNode.isEndOfWord) {
result.push(path.join(''));
currentNode.isEndOfWord = false;
}
```
From that current cell, we'll look at all the directions we can go as long as we stay within the bounds of `board`, and that next character is _the_ next character in that word (if it's a child node of the current node):
```ts
// Coordinations to go right, left, down, and up
let coords = [[0, 1], [0, -1], [1, 0], [-1, 0]];
for (const [r, c] of coords) {
let [rowToGo, colToGo] = [currentRow + r, currentCol + c];
if (!outOfBounds(rowToGo, colToGo) && currentNode.children.has(board[rowToGo][colToGo])) {
dfs(
rowToGo,
colToGo,
currentNode.children.get(board[rowToGo][colToGo]) as TrieNode,
path
);
}
}
```
Once we have done exploring our options, we need to backtrack, so we need to pop the last character from our `path` and reset the cell to its original character:
```ts
path.pop();
board[currentRow][currentCol] = currentChar;
```
And, that's pretty much it for the `dfs` function:
```ts
function dfs(currentRow: number, currentCol: number, currentNode: TrieNode, path: string[]) {
let currentChar = board[currentRow][currentCol];
path.push(currentChar);
board[currentRow][currentCol] = '*';
// If we find a word, we'll add it to result, and
// mark that node as not the end character
// because it might be in another word
if (currentNode.isEndOfWord) {
result.push(path.join(''));
currentNode.isEndOfWord = false;
}
// Coordinations to go right, left, down, and up
let coords = [[0, 1], [0, -1], [1, 0], [-1, 0]];
for (const [r, c] of coords) {
let [rowToGo, colToGo] = [currentRow + r, currentCol + c];
if (!outOfBounds(rowToGo, colToGo) && currentNode.children.has(board[rowToGo][colToGo])) {
dfs(
rowToGo,
colToGo,
currentNode.children.get(board[rowToGo][colToGo]) as TrieNode,
path
);
}
}
path.pop();
board[currentRow][currentCol] = currentChar;
}
```
And, the whole solution looks like this:
```ts
class TrieNode {
public children: Map<string, TrieNode>;
public isEndOfWord: boolean;
constructor() {
this.children = new Map();
this.isEndOfWord = false;
}
}
class Trie {
public root: TrieNode;
constructor() {
this.root = new TrieNode();
}
addWord(word: string) {
let currentNode = this.root;
for (const char of word) {
if (!currentNode.children.has(char)) {
currentNode.children.set(char, new TrieNode());
}
currentNode = currentNode.children.get(char) as TrieNode;
}
currentNode.isEndOfWord = true;
}
}
function findWords(board: string[][], words: string[]): string[] {
const rowsLength = board.length;
const colsLength = board[0].length;
function outOfBounds(r: number, c: number) {
return r < 0 || c < 0 || r >= rowsLength || c >= colsLength;
}
let result: string[] = [];
let trie = new Trie();
for (const word of words) {
trie.addWord(word);
}
function dfs(currentRow: number, currentCol: number, currentNode: TrieNode, path: string[]) {
let currentChar = board[currentRow][currentCol];
path.push(currentChar);
board[currentRow][currentCol] = '*';
// If we find a word, we'll add it to result, and
// mark that node as not the end character
// because it might be in another word
if (currentNode.isEndOfWord) {
result.push(path.join(''));
currentNode.isEndOfWord = false;
}
// Coordinations to go right, left, down, and up
let coords = [[0, 1], [0, -1], [1, 0], [-1, 0]];
for (const [r, c] of coords) {
let [rowToGo, colToGo] = [currentRow + r, currentCol + c];
if (!outOfBounds(rowToGo, colToGo) && currentNode.children.has(board[rowToGo][colToGo])) {
dfs(
rowToGo,
colToGo,
currentNode.children.get(board[rowToGo][colToGo]) as TrieNode,
path
);
}
}
path.pop();
board[currentRow][currentCol] = currentChar;
}
for (let i = 0; i < rowsLength; i++) {
for (let j = 0; j < colsLength; j++) {
if (trie.root.children.has(board[i][j])) {
dfs(i, j, trie.root.children.get(board[i][j]) as TrieNode, []);
}
}
}
return result;
}
```
#### Time and space complexity
The time complexity of `findWords` can be, in the worst case, {% katex inline %} O(m * n * w) {% endkatex %} where {% katex inline %} m {% endkatex %} is the length of rows, {% katex inline %} n {% endkatex %} is the length of columns, and {% katex inline %} w {% endkatex %} is the total number of words — because we might explore all the cells searching for each word.
For the space complexity, first, we have our trie whose storage needs will grow as the total number of characters in `words` grow. We can say that it's {% katex inline %} O(s) {% endkatex %} where {% katex inline %} s {% endkatex %} is the number of all characters in `words`. We also store a `path` array in our depth-first search, in the worst case where we need to store every unique cell, we'll end up storing the whole board, so it can have {% katex inline %} O(m * n) {% endkatex %} space complexity where {% katex inline %} m {% endkatex %} is the length of rows and {% katex inline %} n {% endkatex %} is the length of columns.
Combining them together, I think, the space complexity might end up being {% katex inline %} O(s + m * n) {% endkatex %}.
---
If some of the parts still doesn't make sense, that's okay. This is a very, _very_ tough problem, and honestly, backtracking is one of the most challenging concepts that's somewhat easy to wrap your mind around theoretically, but not so easy in practice.
Now that we're done with this chapter as well, it's time for another deep breath.
Next up, we'll take a look at the graph data structure. Until then, happy coding.
| rivea0 |
1,873,235 | Buy Xanax Online - Instant Delivery within the US | Click To buy:https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T19:01:54 | https://dev.to/david_leo/buy-xanax-online-instant-delivery-within-the-us-2fb6 | Click To buy:https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| david_leo | |
1,873,234 | Classifying Social Media Texts into Multiple Hate-Based Categories for Indian languages | By: K Chaitanya Balaji Reddy - SE23MAID007 M Batul Abbas - SE23MAID010 N Ananda Varaprasada Babu -... | 0 | 2024-06-01T19:01:41 | https://dev.to/batul02/classifying-social-media-texts-into-multiple-hate-based-categories-for-indian-languages-1me9 | nlp, python, sentiment, hindiwordnet | By:
K Chaitanya Balaji Reddy - SE23MAID007
M Batul Abbas - SE23MAID010
N Ananda Varaprasada Babu - SE23MAID011
K Harsha - SE23MAID006
## Introduction
Hate speech is widespread on platforms like Twitter, Facebook, comment sections, blogs, and biased online publications. Existing profanity filters often miss subtle attacks or contextually hateful speech that uses seemingly harmless words. This project aims to develop a tool to detect hate speech in Hindi tweets, categorizing them as “weakly hateful,” “strongly hateful,” or “no hate” based on the level of hate content. Our model uses a rule-based approach, leveraging sentiment analysis and subjectivity analysis to assess the polarity of sentiment expressions. Objective sentences are removed from the corpus, and a hate speech classifier is built using a lexicon extracted from the corpus. The hate speech detector’s effectiveness is tested in real-world web discourse scenarios.
### The Corpus
Political and social issues often trigger strong emotions, leading to rudeness and hate speech in discussions, especially on platforms like Twitter. Our corpus consists of tweets mostly of a political or social nature, pre-segregated into various hatefulness categories using a CSV file. The categories are:
• Non-hostile
• Fake
• Defamation
• Offensive
• Hate
These categories are not mutually exclusive; a tweet can belong to multiple categories simultaneously. For example, a tweet marked as fake could also be defamatory and offensive. Non-hostile tweets do not fall into any other categories as they are devoid of malintent.
The Algorithm
The algorithm is divided into three main steps:
1. Subjectivity Analysis
2. Building a Hate Speech Lexicon
3. Identifying Theme-Based Nouns
## Subjectivity Analysis
Subjectivity analysis is a crucial step in our algorithm as it helps to filter out objective tweets that are unlikely to contain hate speech. Objective tweets typically present facts or information without any emotional bias, which makes them less likely to be hateful. By focusing on subjective tweets, which are more likely to express opinions and emotions, we can more accurately identify potential hate speech.
### The Role of Subjectivity Analysis
In the context of hate speech detection, subjectivity analysis serves several important purposes:
1. Reduction of Noise: The primary function of subjectivity analysis is to reduce the noise in the dataset. Objective tweets, such as those reporting news or sharing information, do not contribute to the hate speech problem. By removing these tweets from the analysis, we can focus on the tweets that are more likely to contain hateful content, thereby increasing the efficiency and accuracy of our model.
2. Enhanced Precision: By filtering out objective tweets, we narrow down the dataset to those tweets that are more likely to express subjective opinions and emotions. This enhances the precision of our hate speech detection as the remaining tweets are more likely to contain language that reflects personal biases, prejudices, and potential hate speech.
3. Efficient Use of Resources: Processing a large dataset can be computationally intensive and time-consuming. By eliminating objective tweets, we can allocate our computational resources more effectively to analyze subjective tweets. This allows us to build a more focused and efficient model for detecting hate speech.
4. Contextual Relevance: Subjective tweets often contain context-specific language and expressions that are crucial for identifying hate speech. By concentrating on these tweets, we can better understand the context in which certain words or phrases are used, which is essential for accurately detecting hate speech that may be veiled or context-dependent.
### Implementation with HindiWordNet & Stanza
To implement subjectivity analysis, we use HindiWordNet, a lexical database specifically designed for the Hindi language. HindiWordNet assigns positive and negative scores to each word based on its sentiment. The process involves the following steps:
1. Scoring Words: Each word in the tweet is assigned a sentiment score from HindiWordNet. Positive scores indicate a positive sentiment, while negative scores indicate a negative sentiment.
2. Aggregating Scores: The scores of all words in a tweet are aggregated to calculate a total sentiment score for the tweet.
3. Threshold for Subjectivity: Tweets with a total score above 1.0 or below -0.5 are considered sufficiently subjective for further analysis. The threshold values are determined based on empirical observations, where tweets with higher positive or negative scores are more likely to express strong opinions or emotions.
4. Filtering: Tweets that do not meet the subjectivity threshold are filtered out, leaving a subset of tweets that are more likely to contain subjective content and, consequently, potential hate speech.
The Stanza library, developed by the Stanford NLP Group, provides comprehensive support for Hindi language processing, making it an excellent tool for tasks like tokenization, part-of-speech tagging, and dependency parsing in hate speech detection projects. Its pre-trained models ensure high accuracy and efficiency in extracting linguistic features crucial for identifying and analyzing hate speech in Hindi.
### Importance of Subjectivity Analysis
The need for subjectivity analysis in hate speech detection cannot be overstated. Without this step, the model would need to process a large number of objective tweets that do not contribute to the problem of hate speech, thereby diluting the effectiveness of the analysis. By focusing on subjective tweets, we can more accurately identify hate speech, improve the model’s performance, and ensure that our computational resources are used efficiently.
In conclusion, subjectivity analysis is a vital component of our hate speech detection algorithm. It allows us to filter out irrelevant content, focus on emotionally charged and opinionated tweets, and improve the precision and efficiency of our hate speech detection efforts.
## Building a Hate Speech Lexicon
A critical component of our hate speech detection algorithm involves constructing a comprehensive lexicon of words and phrases that signify hate speech. This lexicon is built in multiple stages, using various linguistic resources and techniques to ensure its robustness and relevance.
### Role of SUBJCLUE Lexicon
The first step in building our hate speech lexicon is to leverage the SUBJCLUE lexicon, which contains words annotated with sentiment scores. Words from the SUBJCLUE lexicon are categorized based on their sentiment scores:
• Strongly Negative Words: Words with a total score less than -0.25 are classified as strongly negative. These words are likely to carry strong negative sentiments and are essential for identifying intense hate speech.
• Weakly Negative Words: Words with scores greater than -0.25 but still negative are considered weakly negative. These words, while not as intense, still contribute to the overall negative sentiment and potential hate content in tweets.
This initial categorization helps in detecting the negative polarity of words, forming the foundation for our hate speech lexicon.
### Expansion with SYNSET
The next crucial step involves expanding this initial lexicon using SYNSET, which plays a pivotal role in building a more comprehensive and interconnected web of lexicons.
What is SYNSET?
SYNSET (short for Synonym Set) refers to a set of synonyms that share a common meaning. In linguistic databases like WordNet or its regional variants like HindiWordNet, a SYNSET groups words that can be used interchangeably in various contexts. This semantic relationship is harnessed to enhance our lexicon’s coverage and accuracy.
### Role of SYNSET in Lexicon Building
1. Identifying Seed Verbs: Initially, we manually select a list of seed verbs from the dataset that are believed to carry hateful connotations. These verbs are chosen based on their frequent usage in hateful tweets and their potential to express hate.
2. Expanding with Synonyms: Using SYNSET, we identify all possible synonyms of these seed verbs. This step significantly broadens the scope of our lexicon by including words that, while not present in the initial dataset, share the same hateful connotations. For example, if “attack” is a seed verb, SYNSET helps us include synonyms like “assault,” “bash,” “blast,” etc.
3. Forming a Hate-Verbs Lexicon: The expanded list of synonyms is then compiled into a final hate-verbs lexicon. This lexicon is more exhaustive and covers a wider range of hateful expressions, ensuring that our hate speech detection model can recognize various forms of hate speech, even if they use different words to convey the same sentiment.
4. Interconnected Lexicons: By leveraging SYNSET, we create a web of lexicons where each word is interconnected through its synonyms. This web-like structure enhances the model’s ability to detect hate speech by understanding the semantic relationships between words. It allows the model to capture nuanced expressions of hate that might otherwise be missed if only a limited set of words were considered.
### Benefits of Using SYNSET
• Comprehensive Coverage: SYNSET ensures that the lexicon covers a broad spectrum of words with similar meanings, making the detection process more robust.
• Contextual Understanding: By including synonyms, the model gains a better understanding of the context in which certain words are used, improving the accuracy of hate speech detection.
• Adaptive Lexicon: The lexicon becomes adaptive and dynamic, capable of evolving as new synonyms and expressions of hate speech emerge over time.
In summary, SYNSET plays a crucial role in expanding the hate speech lexicon, creating a comprehensive and interconnected web of lexicons. This expansion enhances the model’s ability to detect hate speech accurately by incorporating a wide range of synonymous expressions, thereby improving the overall effectiveness of the hate speech detection algorithm.
## Theme-Based Nouns
To accurately detect hate speech, it is essential to identify and analyze not only verbs and adjectives but also the nouns that often appear in hateful contexts. This step involves a detailed examination of noun phrases (NPs) within the corpus to pinpoint those frequently used in hateful tweets. By doing so, we can create a targeted list of nouns that enhance the precision of our hate speech detection model.
### Importance of Analyzing Noun Phrases
Noun phrases are crucial in understanding the context and targets of hate speech. They often include the subjects and objects of sentences, which can reveal who or what is being targeted by hateful language. Analyzing noun phrases allows us to:
1. Identify Targets of Hate Speech: Noun phrases often include names of individuals, groups, or entities that are the targets of hate speech. Recognizing these targets helps in understanding the focus of the hate content.
2. Contextual Relevance: By examining the noun phrases, we can ensure that the identified hate speech is relevant to the specific topics being discussed. This relevance is vital for accurately detecting and categorizing hate speech.
3. Enhance Lexicon with Context-Specific Terms: Adding frequently used noun phrases to our lexicon ensures that the hate speech detection model captures context-specific hate speech that might otherwise be overlooked.
### Process of Analyzing Noun Phrases
1. Segregating the Corpus: The corpus is divided into individual noun phrases. This involves using natural language processing techniques to parse sentences and extract noun phrases, which typically consist of a noun and its modifiers.
2. Frequency Analysis: Once the noun phrases are extracted, we conduct a frequency analysis to identify the most commonly used noun phrases in tweets marked as hateful. This step helps in recognizing the key terms that frequently appear in hate speech.
3. Building the Noun Lexicon: The recurrent nouns and noun phrases identified from the frequency analysis are compiled into a text file. This list forms a part of our hate speech lexicon, focusing specifically on nouns relevant to the discussion topics.
4. Ensuring Relevance: The noun phrases added to the lexicon are reviewed to ensure they are pertinent to the types of hate speech being analyzed. This step ensures that our model remains focused on the relevant context and does not include irrelevant or overly generic terms.
### Benefits of Including Theme-Based Nouns
1. Improved Detection Accuracy: Including theme-based nouns in the lexicon improves the accuracy of the hate speech detection model by capturing context-specific language.
2. Context Awareness: The model becomes more aware of the context in which certain nouns are used, allowing for more precise identification of hate speech.
3. Enhanced Coverage: By identifying and including frequently used noun phrases, the lexicon covers a broader range of hate speech expressions, making the detection process more comprehensive.
4. Focus on Relevant Content: The focus on noun phrases ensures that the detection model targets relevant content, reducing false positives and increasing the precision of hate speech identification.
In summary, the process of analyzing noun phrases and incorporating frequently used nouns into the lexicon is a crucial step in enhancing the accuracy and relevance of our hate speech detection model. By focusing on context-specific terms, we ensure that the model can accurately detect and categorize hate speech in various contexts, thereby improving its overall effectiveness.
## Final Testing
The lexicons are tested on the corpus to evaluate their impact on hate speech detection accuracy. The algorithm’s components are tested individually to assess each lexicon’s contribution. The following criteria are used to classify tweets:
• Strongly Hateful: Tweets with two or more strongly negative words, or a combination of strongly negative words with hate-verbs or theme-based nouns.
• Weakly Hateful: Tweets with one strongly negative word or a combination of weakly negative words with theme-based nouns or hate-verbs.
• Non-Hateful: Tweets that do not meet the above criteria.
The results are compared with the manually defined objective results using precision, recall, and F-score metrics.
As you can see, the hate-verbs alone do not make too much of a difference to the accuracy of our model, but adding the themed-noun lexicon improves it relatively significantly.
Clearly, using subjectivity clues makes a very significant improvement to the accuracy of our hate-speech detector (nearly 7% increase in the F-score), which shows the importance of checking for contextual nouns while searching for and detecting hate speech. Another noteworthy factor is how the Recall is much higher than the precision; much higher, in fact, than the Recall value of the original project we referred to even though the precision we get is relatively lower. We argue this is due to our algorithm being efficient with ensuring that the hate-speeches are tagged correctly, as are the innocuous tweets. Thus, it leaves few false negatives (i.e. misses) behind. There are, however, relatively more false positives which takes away from precision. We argue that this is caused by our objective criterion (as described above) not being particularly objective at separating weak hate from strong hate because of the misalignment between criteria used by the corpus to tag hate speeches, and the criteria we ourselves use to segregate them. However, our algorithm compares favorably to the original in terms of segregating non-hate tweets from hateful tweets (about 66% precision in segregating non-hate) because of the criteria being more objective.
## Conclusion
The detection of hate speech in widely spoken languages like Hindi is increasingly important in today's digital era. Our model employs a rule-based approach to identify lexical patterns, allowing us to detect and quantify hate speech with reasonable precision. A key component of our algorithm is the analysis of subjectivity, which significantly enhances the accuracy of hate speech detection. Additionally, we categorize the detected hate speech to provide a more detailed understanding of the content, which helps prioritize our actions if needed.
| batul02 |
1,873,233 | Buy Xanax Online - Same Day Shipping Services Available | Click To buy:https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T19:01:25 | https://dev.to/david_leo/buy-xanax-online-same-day-shipping-services-available-3mc6 | Click To buy:https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| david_leo | |
1,873,231 | Buy Xanax Online - Fast Venmo Delivery for Quick Relief | Click To buy:https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T18:56:38 | https://dev.to/david_leo/buy-xanax-online-fast-venmo-delivery-for-quick-relief-5036 | Click To buy:https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| david_leo | |
1,873,230 | PAT TASK 17 Selenium | Q: What is selenium? Why do we use Selenium for automation ? A: Selenium is a free(Open Source)... | 0 | 2024-06-01T18:56:10 | https://dev.to/jalikatti/pat-task-17-selenium-4aae | Q: What is selenium? Why do we use Selenium for automation ?
A: Selenium is a free(Open Source) automated testing suite for web applications across different browsers and platforms. It is primarily used for automating web based applications and is known for its ability to control the browser by directly communicating with it. Selenium provides a range of tools and libraries aims at supporting browser automation, including a playback tool for authoring functional tests across most modern web browsers, a test domain-specific language to write tests in various programming languages, and a collection of language specific bindings to drive a browser. selenium runs on windows , Linux and Mac OS and is released under the Apache license 2.0.
Multiple programming languages can be used such as JAVA, C, Python to create selenium test scripts. Hence testing done using selenium testing toll is usually referred to as selenium testing.
Selenium software is not just a single tool, Its a suite of software, each piece catering to different selenium QA testing needs of an organization.
In summary, Selenium is preferred for automation due to its versatility, cross-browser testing capabilities, language support, community backing, cost-effectiveness, and integration with CI/CD tools.
<u>Below are the list tools:</u>
1. Selenium Integrated development Environment : Selenium Integrated Development Environment (IDE) is the simplest framework in the Selenium suite and is the easiest one to learn.
It is a Chrome and Firefox plugin that you can install as easily as you can with other plugins
because of its simplicity, Selenium IDE should only be used as a prototyping tool. If you want to create more advanced test cases,
you will need to use either Selenium RC or WebDriver
2. Selenium Remote Control (RC) : Selenium RC was the flagship testing framework of the whole Selenium project for a long time.
This is the first automated web testing tool that allows users to use a programming language they prefer to use.
As of today version 2.25.0, and also RC can support the following programming languages:
Languages Supported: JAVA,C#,PHP,PYTHON,PERL,RUBY.
3. Web Driver : WebDriver proves to be better than Selenium IDE and Selenium RC in many aspects.
It implements a more modern and stable approach in automating the browser’s actions.
WebDriver, unlike Selenium RC, does not rely on JavaScript for Selenium Automation Testing.
It controls the browser by directly communicating with it.
Languages Supports: JAVA,C#,PHP,PYTHON,PERL,RUBY.
4. Selenium Grid : Selenium Grid is a tool used together with Selenium RC to run parallel tests across different machines and different browsers all at the same time.
Parallel execution meaning running multiple tests at once.
**Selenium is used for automation due to several reasons:
**
1. Web Application Automation: Selenium is primarily used for automating web applications for testing purposes, but it is not limited to just that. It can also automate boring web-based administration tasks, making it a versatile tool for automation
2. Cross-Browser Testing: It allows for testing web applications across different browsers and platforms, making it suitable for cross-browser testing
3. Language Support: Selenium supports a number of popular programming languages, including JavaScript, C#, Groovy, Java, Perl, PHP, Python, Ruby, and Scala, making it accessible to a wide range of developers
4. Community Support: Selenium has a rapidly growing community, with helpful documentation and tutorials available for developers and testers to start with Selenium automation testing.
Cost and Portability: Selenium is freeware with no upfront direct costs involved, and its community-based support is freely available. It can be freely downloaded and used, making it cost-effective and portable
5. Integration and Scalability: Selenium can be easily integrated with different CI/CD tools like Jenkins, CircleCI, Bamboo, Azure DevOps, Docker, etc., and it offers features such as fast feedback loop, automation at scale, and parallel testing
**Advantages of Selenium for Automated Testing:
**
1. Language and Framework Support
Selenium supports all major languages like Java, Python, JavaScript, C#, Ruby and pearl for software test automation.
we can write our steps in any of these programming languages, and Selenium will convert it into a Selenium compatible course in no time.
There is no requirement for no in Selenium only languages.
Also, every Selenium supported language has appropriated three works that help write test scripts for Selenium test automation.
So when we go for Selenium as a tool for performing automation testing,
we won’t have to worry about language and framework support as Selenium will do that for us.
2. Open Source Availability
The availability of open source code is one of the benefits of Selenium.
Selenium is a publicly available automation framework that is free to use because it is an open-source product.
Work can be saved here and used for other beneficial purposes.
The Selenium community is always willing to assist developers and software engineers in automating web browser capabilities and functionality.
Selenium, as an open-source technology, also allows us to customize the code for easier management
and to improve the functionality of preset methods and classes.
3. Multi-Browser Support
The Selenium community has been working on improvising every day on one Selenium script for all browsers.
According to StatCounter, Chrome, Firefox, Safari, Internet Explorer, and browsers worldwide,
and Selenium benefits are compatible with all these mentioned browsers.
You must not write a script for every browser as just one script is required for all browsers.
4. Support Across Various Operations
Different people use various operating systems, and your automation tool must support all of them.
Selenium is a highly profitable tool supporting and could work across different operating systems like Windows, Linux, Mac OS, Unix, etc.
5. Ease of Implementation
The selenium automation framework is very easy to use as it provides a user-friendly interface
that helps users create and execute test scripts easily and effectively.
we can also watch while the test runs and analyses detailed reports of the selenium test and takes follow-up actions.
| jalikatti | |
1,873,229 | Buy Xanax Online - Easy Payments with Zelle Option | Click To buy:https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T18:53:50 | https://dev.to/david_leo/buy-xanax-online-easy-payments-with-zelle-option-3oaa | Click To buy:https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| david_leo | |
1,873,228 | Let's Start Exploring OOP without saying OOPS. #Day1 | Think Like an Object: A Fresh Approach to Programming Let Me Start with WHAT IS... | 0 | 2024-06-01T18:53:20 | https://dev.to/developervignesh/lets-start-exploring-oop-without-saying-oops-day1-3c9e | oop, java, basic, webdev | Think Like an Object: A Fresh Approach to Programming
**Let Me Start with WHAT IS WHAT**
_**Object-Oriented Programming (OOP)** is a paradigm that uses "objects" to design applications and programs._
**An object** is a self-contained unit that combines data (attributes or properties) and behavior (methods or functions) into a **single entity**. For now, imagine an object as a blueprint for a real-world thing.
If you're new to OOP, the definition might seem confusing because of the unfamiliar terminology.
Let's simplify it by comparing it to a real-world example, like a movie.
**Understanding Domains in OOP**
You might wonder, why are we talking about domains? Well, a domain is a core building block in OOP. Think of a domain as a fundamental category or concept in the real world. For instance, let's consider the domain of "Movie."
**Breaking Down the Movie Domain**
A Movie is a domain. But what makes up a movie? Movies can be of various types, such as Action, Comedy, and Drama. Each type has its own unique properties and behaviors. Let's break it down:
- **Action Movie**: What makes an action movie unique? It has action sequences, stunts, and fast-paced scenes. These are its specific properties and behaviors.
- **Comedy Movie**: How about a comedy? It focuses on humor, funny dialogues, and entertaining plots.
- **Drama Movie**: And a drama? It emphasises emotional storytelling, complex characters, and serious themes.
**Connecting to OOP**
In OOP, we create objects that represent these real-world entities. Each object (like an Action Movie) will have its own attributes (like stunts, special effects) and methods (like `playActionSequence()`).
So, by thinking of a domain as a core concept and its types as specific variations with unique properties and behaviors, you can better understand how OOP models real-world scenarios.
### Key Points to Remember
- **Domain**: A core concept or category (e.g., Movie).
- **Types of Domain**: Specific variations within the domain (e.g., Action, Comedy, Drama).
- **Properties and Behaviors**: Unique characteristics and actions of each type (e.g., action sequences for Action Movies).
By comparing OOP concepts to real-world examples, it becomes easier to grasp how objects, domains, and their types work together to create complex and dynamic programs.
**_Understanding the Four Pillars of Object-Oriented Programming (OOP) Through the Example of a Movie_**
Object-Oriented Programming (OOP) isn't just about creating objects; it's built on four main pillars that make it a powerful and widely-used programming paradigm. Without these pillars, OOP would lose its strength and structure. Let's explore these foundational concepts using the example of a movie.
**Why are these pillars important?**
You might wonder why we refer to them as the pillars of OOP. It's because, without these core concepts, OOP wouldn't be as robust and effective. These pillars give OOP its structure, making it a reliable and efficient way to design and build applications.
**_The Four Pillars of OOP__**
**1. Encapsulation**
**What is Encapsulation?**
Encapsulation is about bundling the data (attributes) and methods (functions or behaviours) that operate on the data into a single unit, typically a class.
**Real-World Example:**
Think of a movie. "Epic Quest" has various details like the title, genre, duration, and cast. These details are encapsulated within the movie, and viewers interact with the movie as a whole rather than its individual parts. You don’t need to know all the production details to enjoy it; you just watch it.
**In Programming:**
In OOP, encapsulation bundles data and methods within a class. For example, a `Movie` class might have attributes like title, genre, and duration, and methods like play, pause, and stop. This hides the internal workings and exposes only necessary interfaces.
**Why is it needed and beneficial?**
Encapsulation protects the integrity of the data by preventing outside interference and misuse. It makes the code more modular and easier to maintain. By hiding complex details, it simplifies interaction and usage.
**_2. Abstraction_**
**What is Abstraction?**
Abstraction means hiding complex implementation details and showing only the necessary features of an object. This simplifies the interaction with the object.
**Real-World Example:**
When you watch a movie, you see the final product on the screen, not the behind-the-scenes work like editing, special effects, and direction. The complex details are hidden, and you can enjoy the movie through a simple interface.
**In Programming:**
In OOP, abstraction allows you to interact with objects at a high level. For example, a `StreamingService` class might have methods like watchMovie, browseMovie without exposing the complex logic behind these actions.
**Why is it needed and beneficial?**
Abstraction makes the code more readable and easier to understand. By exposing only the necessary details, it reduces complexity and enhances usability.
#### 3. Inheritance
**What is Inheritance?**
Inheritance allows a new class to inherit properties and behaviors (methods) from an existing class. This promotes code reuse and establishes a hierarchical relationship between classes.
**Real-World Example:**
Think of movie genres. A general class called `Movie` might have properties like title and duration, and behaviors like play and pause. Specific genres like `ActionMovie` and `DramaMovie` can inherit these properties and behaviors, and also have additional features.
**In Programming:**
In OOP, you can create an `ActionMovie` class that inherits from the `Movie` class. This way, `ActionMovie` will have all the properties and methods of `Movie`, plus any additional ones defined in `ActionMovie`.
**Why is it needed and beneficial?**
Inheritance allows for code reuse and a clear structure. It helps in creating a more organized and manageable codebase.
**4. Polymorphism**
**What is Polymorphism?**
Polymorphism allows objects to be treated as instances of their parent class rather than their actual class. This enables one interface to be used for a general class of actions, with specific behavior determined at runtime.
**Real-World Example:**
Consider different movie genres like Action, Comedy, and Drama. Each genre has a play method, but the experience is different. An action movie has thrilling sequences, a comedy has funny scenes, and a drama has emotional storytelling.
**In Programming:**
In OOP, polymorphism allows you to call the play method on any `Movie` object, whether it’s an `ActionMovie`, `ComedyMovie`, or any other genre, and the correct method for that genre will be executed.
**Why is it needed and beneficial?**
Polymorphism makes the code more flexible and scalable. It allows the same method to perform different tasks based on the object it is acting upon, enhancing the ability to extend and maintain the code.
**Conclusion**
The four pillars of OOP—Encapsulation, Abstraction, Inheritance, and Polymorphism—form the foundation that makes Object-Oriented Programming robust, efficient, and easy to use. By understanding and applying these principles, you can create well-structured and maintainable code, making software development more efficient and manageable.
Next time you watch a movie, think about it in terms of objects and OOP. How would you represent your favorite film as an object, and what attributes and behaviors would it have? By drawing parallels between real-world examples and OOP concepts, you can program and appreciate the elegance of this powerful paradigm.
I trust you now have a clear understanding of object-oriented programming (OOP) without explicitly mentioning "OOP." Feel free to provide feedback if there are any areas you believe could be improved.
| developervignesh |
1,873,227 | VS Code extensions for React developers | Visual Studio Code, often abbreviated as VS Code, is a free and open-source source code editor... | 0 | 2024-06-01T18:49:22 | https://dev.to/kevinbenjamin77/vs-code-extensions-for-react-developers-3k35 | webdev, react, vscode, beginners | Visual Studio Code, often abbreviated as VS Code, is a free and open-source source code editor developed by Microsoft. It's known for its versatility, lightweight design, and extensive customization options, making it one of the most popular choices among developers across various programming languages and platforms.
## Essential Extensions
### ESLint
ESLint is a powerful static code analysis tool widely used in React development for enforcing coding standards, identifying potential errors, and ensuring code consistency. Here's a breakdown of its benefits and features specifically tailored for React
**Benefits for React development**
- **Code Consistency**: ESLint helps maintain consistent coding styles across React projects, even in teams with multiple developers. This is crucial for readability and maintainability.
- **Catch Common Errors**: React applications often have complex component hierarchies and state management. ESLint can catch common errors and pitfalls specific to React, such as missing key props, unused variables, or incorrect usage of lifecycle methods.
- **Enforce Best Practices**: ESLint can enforce React best practices, such as using propTypes, defaultProps, and proper usage of JSX, ensuring that React code follows established guidelines for performance and reliability.
- **Integration with Build Pipelines**: ESLint seamlessly integrates into build pipelines, enabling automatic code analysis during development or as part of continuous integration (CI) processes. This helps catch errors early in the development lifecycle.
**Features and functionality**
- **Customizable Rules**: ESLint comes with a wide range of built-in rules covering common JavaScript and React patterns. Additionally, it allows developers to create custom rules tailored to specific project requirements.
- **Extensible**: ESLint is highly extensible and supports plugins, enabling integration with tools like TypeScript, JSX, and frameworks beyond React.
- **Automatic Fixes**: ESLint not only identifies issues but can also automatically fix many of them through the --fix option or with editor integrations. This feature saves developers time by automating code cleanup tasks.
- **Editor Integrations**: ESLint seamlessly integrates with popular code editors like Visual Studio Code, Atom, and Sublime Text, providing real-time feedback and suggestions as developers write code.
- **Shareable Configurations**: ESLint allows teams to define shareable configurations, ensuring consistent rule sets across projects and enabling easy adoption of best practices.
- **Support for JSX**: ESLint has built-in support for JSX syntax, enabling it to analyze React-specific patterns and provide feedback on JSX usage.
### Prettier
Prettier is a code formatting tool that automatically formats your code to ensure consistency and readability. Here's why it's particularly valuable for React development
**Automatic code formatting**
- **Consistency**: Prettier enforces consistent code formatting across the entire codebase, ensuring that all developers adhere to the same style conventions. This consistency improves code readability and maintainability.
- **Time-Saving**: Instead of manually formatting code, Prettier automates the process, saving developers time and effort. This allows developers to focus on writing code rather than worrying about formatting details.
- **Error Reduction**: Manual code formatting can lead to errors, such as inconsistent indentation or misplaced brackets. Prettier eliminates these errors by automatically applying formatting rules, reducing the risk of bugs in the codebase.
- **Configurability**: While Prettier comes with sensible default formatting rules, it also offers configuration options to customize formatting preferences according to project requirements. Developers can adjust settings such as indentation size, line length, and whether to use single or double quotes.
**Integration with React projects**
- **Seamless Integration**: Prettier seamlessly integrates with React projects, supporting JSX syntax out of the box. This means it can format JSX elements, props, and expressions without any additional configuration.
- **Editor Integrations**: Prettier provides plugins or extensions for popular code editors like Visual Studio Code, Atom, and Sublime Text. These integrations enable developers to format code directly within their editor with a simple keystroke or automatically save.
- **Pre-commit Hooks**: Prettier can be set up as a pre-commit hook in version control systems like Git. This ensures that all code commits to adhere to formatting standards before being pushed to the repository, maintaining consistency in collaborative projects.
- **Build Pipeline Integration**: Prettier can be integrated into build pipelines and CI/CD processes to automatically format code during development or as part of the deployment pipeline. This ensures that code formatting is consistently applied across all environments.
## React-specific Extensions
**React Developer Tools**
React Developer Tools is a browser extension that provides developers with debugging and profiling capabilities specifically tailored for React applications. While it primarily operates within web browsers like Chrome and Firefox, it can complement the development workflow in Visual Studio Code (VS Code) through the following means:
**Integration with VS Code**
- **Direct Integration**: While React Developer Tools primarily functions as a browser extension, developers can use it in conjunction with VS Code by running their React applications in a browser window while simultaneously editing code in the VS Code editor.
- **Code Inspection**: While debugging React applications in the browser, developers can switch back and forth between the browser's developer tools and VS Code. They can inspect React component code in VS Code to understand and debug issues identified in the browser.
- **Code Navigation**: VS Code's built-in features, such as Go to Definition and Find All References, can be utilized to navigate through React component code, making it easier to trace the source of bugs identified using React Developer Tools.
**Features for debugging React applications**
- **Component Hierarchy**: React Developer Tools visually represents the component hierarchy for the currently rendered React application. Developers can inspect the hierarchy to understand how components are nested and composed.
- **Props and State Inspection**: Developers can inspect the props and state of individual components, allowing them to understand how data flows through the application and identify any inconsistencies or unexpected behavior.
- **Component Highlighting**: React Developer Tools highlights components in the browser's DOM inspector, making it easier to identify which components correspond to specific elements on the page.
- **Component Tree Navigation**: Developers can navigate through the component tree to inspect the props and state of parent, child, and sibling components, facilitating a deeper understanding of the application's structure and behavior.
- **Performance Profiling**: React Developer Tools includes features for performance profiling, allowing developers to identify performance bottlenecks and optimize rendering performance by analyzing component render times and re-renders.
### ES7 React/Redux/GraphQL/React-Native snippets
ES7 React/Redux/GraphQL/React-Native Snippets is a Visual Studio Code extension that provides developers with a collection of shortcut commands for quickly inserting common code snippets related to React, Redux, GraphQL, and React Native development. Here's why it's valuable for React developers:
**Shortcut commands for common React code snippets**
- **Efficient Code Writing**: This extension offers a set of predefined code snippets for commonly used React patterns, such as creating functional components, class components, stateless components, hooks, and more. Instead of typing out boilerplate code manually, developers can use these shortcuts to insert code snippets with minimal effort.
- **Standardized Code Structure**: By providing predefined snippets, the extension helps ensure consistent coding practices across projects and among team members. Developers can easily adhere to established coding conventions and patterns without needing to remember specific syntax or structure.
- **Support for Multiple Technologies**: In addition to React, the extension includes snippets for Redux, GraphQL, and React Native, allowing developers to quickly scaffold code for common tasks in these technologies. This versatility is particularly useful for full-stack developers or those working on projects that utilize multiple technologies.
**Increased productivity for React developers**
- **Faster Development Workflow**: With shortcut commands readily available, developers can significantly speed up their development workflow by reducing the time spent on repetitive tasks. This increased efficiency allows developers to focus more on implementing features and solving complex problems rather than on writing boilerplate code.
- **Improved Code Quality**: By standardizing code structure and reducing the likelihood of manual errors, the extension contributes to improved code quality. Developers can quickly generate code snippets that follow best practices, resulting in cleaner, more maintainable codebases.
- **Focus on Core Functionality**: With the ability to quickly insert common code snippets, developers can devote more time and attention to implementing business logic and application features, rather than getting bogged down in writing mundane code.
- **Reduced Cognitive Load**: The availability of shortcut commands alleviates the need for developers to remember specific syntax or patterns for common tasks. This reduction in cognitive load allows developers to maintain focus and productivity throughout the development process
## Extensions for State Management
### Redux DevTools
Redux DevTools is an essential tool for React developers working with Redux, offering invaluable features for monitoring and debugging Redux state changes. Here's why it's crucial for React development:
**Monitoring Redux state changes**
- **Real-time State Inspectio**n: Redux DevTools provides a visual representation of the Redux store, allowing developers to monitor the application's state in real-time. They can view the current state and track changes made to the state over time, facilitating a deeper understanding of how data flows through the application.
- **Time-Travel Debugging**: One of the standout features of Redux DevTools is its ability to perform time-travel debugging. Developers can rewind and replay actions dispatched to the Redux store, enabling them to step through the application's state at different points in time. This feature is invaluable for diagnosing bugs, understanding application behavior, and reproducing issues reported by users.
- **Action Log**: Redux DevTools maintains a log of actions dispatched to the Redux store, along with the corresponding state changes triggered by each action. This action log provides developers with a comprehensive history of application events, making it easier to trace the flow of data and identify potential issues.
- **State Comparison**: Redux DevTools allows developers to compare different states of the application side-by-side, helping them identify differences and anomalies between states. This feature is particularly useful for troubleshooting complex state management scenarios and optimizing application performance.
**Integration with VS Code for streamlined development**
- **Seamless Integration**: While Redux DevTools primarily operates within web browsers like Chrome and Firefox, developers can integrate it with VS Code by running their React applications in a browser window while simultaneously editing code in the VS Code editor.
- **Code Inspection**: While debugging React applications in the browser using Redux DevTools, developers can switch back and forth between the browser's developer tools and VS Code. They can inspect Redux-related code, such as action creators, reducers, and middleware, in the VS Code editor to understand and debug issues identified in the browser.
- **Code Navigation**: VS Code's built-in features, such as Go to Definition and Find All References, can be utilized to navigate through Redux-related code, making it easier to trace the source of bugs and understand the flow of data within the application.
- **Enhanced Development Workflow**: By integrating Redux DevTools with VS Code, developers can streamline their development workflow, seamlessly transitioning between writing code and debugging application state changes. This integration enhances productivity and facilitates more efficient development and debugging processes.
### MobX React Developer Tools
MobX React Developer Tools is an extension designed to aid React developers who use MobX for state management. Here's why it's essential and the benefits it offers
**Support for MobX state management**
- **Integration with MobX**: MobX React Developer Tools seamlessly integrates with MobX, providing developers with insights and debugging capabilities specific to MobX-powered React applications.
- **State Observation**: The extension allows developers to observe and inspect the MobX state tree in real-time. This feature enables developers to understand how data flows through the application and how changes to the state affect the UI.
- **Reaction Tracking**: MobX uses reactions to automatically update components when relevant data changes. MobX React Developer Tools help developers track these reactions, making it easier to identify which components are being updated in response to state changes.
- **Action Tracking**: MobX encourages the use of actions to modify the state in a predictable and observable manner. The extension tracks these actions, providing developers with a clear view of the actions that triggered state changes.
**Features and benefits for React developers**
- **Real-time State Inspection**: MobX React Developer Tools provide developers with a real-time view of the application's state, allowing them to inspect and debug the state tree as it evolves during runtime. This feature is invaluable for diagnosing bugs and understanding application behavior.
- **Action Replay**: Similar to Redux DevTools, MobX React Developer Tools support time-travel debugging by allowing developers to replay actions and inspect the state at different points in time. This feature simplifies the process of reproducing and debugging complex state-related issues.
- **Component Tracking**: The extension tracks which components are observing specific parts of the MobX state tree. This information helps developers understand the data dependencies between components and optimize re-rendering performance by minimizing unnecessary updates.
- **Performance Monitoring**: MobX React Developer Tools provide insights into the performance of MobX reactions and actions, allowing developers to identify potential bottlenecks and optimize the application's performance.
- **Enhanced Development Experience**: By offering features tailored specifically for MobX-powered React applications, MobX React Developer Tools enhance the development experience, making it easier for developers to build, debug, and maintain MobX-based React applications.
## Testing and Debugging Extensions
### Jest
Jest is a popular testing framework for JavaScript applications, particularly favored by React developers for its simplicity and robustness. Here's why it's essential and how it integrates with Visual Studio Code for testing React applications:
**Integration with VS Code for Jest testing**
- **Test Explorer Integration**: VS Code provides extensions like "Jest Test Explorer" that integrate Jest directly into the editor's interface. This integration displays a tree view of your test suite within VS Code, allowing you to run and debug tests without leaving the editor.
- **Debugging Support**: With Jest Test Explorer, you can debug your tests directly within VS Code. Set breakpoints, step through test code, and inspect variables—all within the familiar VS Code debugging interface.
- **Output Display**: VS Code captures Jest's output and displays it within its console, providing a seamless testing experience without cluttering your terminal window.
- **Configuration Options**: VS Code allows you to configure Jest directly from its settings, enabling you to customize Jest's behavior for your specific project needs without needing to modify configuration files manually.
**Streamlined test execution and debugging**
- **Fast Test Execution**: Jest's parallel test execution and smart test filtering capabilities ensure that your tests run quickly, even as your test suite grows. This enables developers to get rapid feedback on code changes, facilitating a faster development cycle.
- **Snapshot Testing**: Jest's snapshot testing feature allows you to capture the output of your React components and compare it against previously stored snapshots. This simplifies regression testing, ensuring that your UI components render consistently across code changes.
- **Built-in Matchers and Utilities**: Jest provides a rich set of built-in matchers and utilities for asserting test expectations, mocking dependencies, and handling asynchronous code. This reduces the need for external libraries and streamlines the testing process.
- **Interactive Watch Mode**: Jest's interactive watch mode automatically re-runs tests as you make changes to your code, providing immediate feedback on test results. This iterative testing approach encourages test-driven development (TDD) and helps catch regressions early in the development process.
## Productivity Enhancers
### Auto Import
Auto Import is a Visual Studio Code extension that automatically suggests and inserts import statements for modules and components in your JavaScript or TypeScript code. Here's how it benefits React developers and streamlines the development workflow:
**Automatic Import Suggestions for React Components**:
- Effortless Import Management: Auto Import analyzes your code and suggests import statements for modules and components that are not yet imported. For React developers, this means that when you reference a React component in your code, Auto Import will suggest the corresponding import statement, eliminating the need to manually write or search for imports.
- **Support for JSX and TSX**: Auto Import understands JSX syntax in React components and TSX files, allowing it to suggest imports for React components used within JSX expressions. This ensures that React components are properly imported and included in your codebase without errors.
- **Completion for Component Names**: When typing the name of a React component, Auto Import provides suggestions based on the available components in your project. This helps prevent typos and ensures that you import the correct component with the correct name.
**Streamlining Development Workflow**:
- **Time-Saving**: Manually managing import statements can be tedious and time-consuming, especially in large React projects with many components and modules. Auto Import automates this process, saving developers time and effort by suggesting and inserting import statements with a simple keystroke or automatically as you type.
- **Reduced Cognitive Load**: With Auto Import handling import statements, developers can focus more on writing code and implementing features, rather than worrying about managing imports. This reduces cognitive load and allows developers to maintain focus and productivity throughout the development process.
- **Prevent Errors**: Missing or incorrect import statements can lead to errors and runtime issues in React applications. Auto Import helps prevent these errors by ensuring that all required modules and components are properly imported and available for use in your code.
- **Consistent Code Structure**: By automatically inserting import statements according to predefined rules and conventions, Auto Import promotes consistency in code structure and organization across your React project. This makes it easier for developers to navigate and understand the codebase, especially when collaborating with team members
### GitLens
GitLens is a powerful Visual Studio Code extension that enhances the Git version control experience directly within the editor. Here's how it benefits React developers and supports collaborative development.
**Git Version Control within VS Code**:
- **Integrated Git View**: GitLens provides a comprehensive view of your Git repository directly within the VS Code interface. This includes information such as commit history, branches, tags, remotes, and more, allowing you to visualize and navigate your repository without leaving the editor.
- **Commit Annotations**: GitLens annotates each line of code with information about the most recent commit that modified it. This allows you to see who made changes to the code and when, providing valuable context while reviewing or debugging code changes.
- **Blame and History Views**: GitLens offers interactive blame and history views that allow you to explore the evolution of a file over time. You can easily navigate through previous revisions, view commit details, and understand the changes introduced in each commit.
- **Code Lens Integration**: GitLens integrates with VS Code's Code Lens feature to provide additional information and actions related to Git. This includes displaying commit and blame information inline with your code, as well as providing shortcuts for common Git operations such as comparing changes and navigating to commits.
**Features for Collaborative React Development**:
- **Collaborative Code Review**: GitLens facilitates collaborative code review by providing rich visualizations of code changes and commits history directly within the VS Code editor. This allows team members to review each other's code, provide feedback, and discuss changes without switching between different tools or platforms.
- **Branch Management**: GitLens offers features for managing branches, including creating, renaming, merging, and deleting branches directly from within VS Code. This streamlines the branch workflow and helps ensure that team members are working on the correct branches and collaborating effectively.
- **Conflict Resolution**: In collaborative development environments, conflicts may arise when multiple developers make changes to the same code simultaneously. GitLens provides tools for resolving merge conflicts within VS Code, helping teams to quickly and efficiently address conflicts and maintain code integrity.
- **Remote Repository Integration**: GitLens seamlessly integrates with remote Git repositories hosted on platforms like GitHub, GitLab, and Bitbucket. This allows team members to view and interact with remote branches, pull requests, and commits directly within the VS Code editor, simplifying the collaboration process.
## Conclusion
In conclusion, Visual Studio Code (VS Code) stands as a cornerstone for React development, offering a plethora of essential extensions tailored to enhance productivity, streamline workflows, and ensure code quality. With its lightweight design and extensive customization options, VS Code provides a versatile environment for developers across various programming languages and platforms. | kevinbenjamin77 |
1,873,226 | Buy Xanax Online - Find Relief from Anxiety | Click To Buy https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online by using MedXpharma ,this is... | 0 | 2024-06-01T18:47:53 | https://dev.to/david_leo/buy-xanax-online-find-relief-from-anxiety-3inj | Click To Buy https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online by using MedXpharma ,this is an online trusted delivery. Xanax is used to treat anxiety and panic disorders.Xanax affects the central nervous system and calms the brain and nerves By increasing GABA Neurotransmitter writer. Buy Xanax online from the Medxpharma platform with safe transactions and reliable shipping. Trust MedXpharma For your pharmacy Needs And Mind of experience.
Purpose of xanax Is used to treat anxiety disorders and anxiety is caused by depression.
The Advantage of xanax is used to relax the muscles and can produce feelings.
The Disadvantages of xanax are Dizziness,Insomnia,Fatigue,Confusion,Memory Problems,Seizures and Difficulty in concentrating.
Dosage For Adults:0.25 to 0.5 Milligrams (Mg) 3 times a day.your doctor may increase your as you need.
Dosage For Children:0.5 mg taken once a day.Your doctor can also increase the dose as you need.
Short term advantage of xanax can cause drowsiness and sedation.
| david_leo | |
1,873,224 | Bloom Filter | Bloom filter is a probabilistic data structure which is used to to find whether one particular... | 0 | 2024-06-01T18:45:21 | https://dev.to/princekumar799/bloom-filter-14k2 | systemdesign, webdev, backenddevelopment, datastructures | Bloom filter is a probabilistic data structure which is used to to find whether one particular element is a member of a construct.
- If It gives no as answer it is 100% sure that given value is not the member.
- If It gives yes as answer it may not be the member.
- It provides a quick and easy way to discard unwanted read on the disk.
## What Problem does it solve?
Take example of instagram, where you have to keep the record of reels viewed by a person. So, that same reel is not showing again.
## Why do we need this, can’t we implement same thing with set?
Yes, we can implement same functionality with set but the problem lies in implementation of the sets.
Set is implemented using balanced binary trees, where along with data node we keep track of left and right pointers.
Think of Data of 4MB we have to store 8MB of metadata regarding pointers.
## Implementation:
```jsx
class BloomFilter {
constructor(size)
{
this.size = size;
this.bitArray = new Array(size).fill(false);
}
static hash(value, size) {
let hashValue = 5381;
for (let i = 0; i < value.length; i++) {
hashValue = (hashValue * 33) + value.charCodeAt(i);
}
return Math.abs(hashValue) % size;
}
add(value)
{
const indexVal = BloomFilter.hash(value,this.size);
console.log(indexVal);
this.bitArray[indexVal] = 1;
}
contains(value)
{
const indexVal = BloomFilter.hash(value,this.size);
console.log(indexVal);
return this.bitArray[indexVal];
}
}
const bloom = new BloomFilter(10);
bloom.add('hii');
console.log(bloom.contains('hii'),bloom.contains('hi')); // true false
```
| princekumar799 |
1,873,212 | Creating a Reusable Component in React: Handling Unlimited Future Changes | Hi Folks, When working with React, creating reusable components is essential for maintaining clean,... | 0 | 2024-06-01T18:39:33 | https://dev.to/nadeemkhanrtm/creating-a-reusable-component-in-react-handling-unlimited-future-changes-mgi | react, webdev, javascript, beginners |
Hi Folks,
When working with React, creating reusable components is essential for maintaining clean, manageable, and scalable code. One common component that frequently needs to be adaptable and flexible. In this blog post, we’ll explore how to build a reusable component that can handle various configurations and adapt to future changes without becoming overly complex.
**Variants of Headers**
Let's consider a header component that may need to support different variants. Below is an example of different header styles:
**Basic Header Component**
A typical React header component might look something like this, where props are used to conditionally render elements like the logo, navigation items, search bar, and cart.
Using props, a developer might set up the header as follows:
**Usage:**
**Handling Future Changes**
Now, let's consider a scenario where the requirements change. The header needs to include additional elements like a favorites section, user account details, and a top banner with image and text that can be shown or hidden. If we continue using the prop-based approach, the component might look like this:
As you can see, this approach quickly becomes unwieldy with 10-15 props. Managing such a prop-heavy component can lead to cumbersome and error-prone code.
**Using Compound Components**
To address this issue, we can use the **compound component** pattern. This approach allows for more flexible and readable code by enabling the parent component to define the structure and the children to specify the content.
Here's an example of how we can refactor our header component using compound components:
**Header.js**
**Usage**
**Benefits of Compound Components**
**Flexibility**: Compound components provide greater flexibility as they allow you to nest components and pass props directly to the specific parts of the header.
**Readability**: The structure is more readable and maintains a clear hierarchy.
**Scalability**: Adding new components or modifying existing ones becomes easier without making the parent component too complex.
**Reusability**: Each part of the header can be reused independently in different contexts or layouts.
By using the compound component pattern, we ensure that our header component remains manageable and adaptable to future changes, providing a robust solution for complex UI requirements. | nadeemkhanrtm |
1,873,222 | Buy Ambien Online Same Day Shipping Services | https://medxpharma.org/product/xanax-2mg/ Buy Xanax Online from usPharma for a care-free and secure... | 0 | 2024-06-01T18:38:52 | https://dev.to/huisstar/buy-ambien-online-same-day-shipping-services-c68 | https://medxpharma.org/product/xanax-2mg/
Buy Xanax Online from usPharma for a care-free and secure experience. Xanax is an anxiety agent that is used for the cure of anxiety panic attacks, insomnia, and muscle spasms. Xanax is also known as Alprazolam, contains Methyl, Phenyl, triazolo This medication is also used for Panic attacks and anxiety disorders.
Xanax influences the nervous system of the central part and gives relief to the nerves and brain by boosting GABA neurotransmitter levels.
Buy Xanax Online and get satisfied with Online Shopping with great confidence on the internet with instant delivery in just a few hours. Say goodbye to your anxiety and stress, our website provides an easy solution that lets you buy Xanax at your doorstep.
If you are suffering through anxiety, panic disorders or any other similar conditions, Our quick delivery process makes sure you'll have medication when you need it most. Enjoy relaxation and peace of mind and let know it is only a few hours away, which allows you to focus on your health and rebuild your personality.
The dosage of XANAX used for therapy for PD dosage for PD is 0.5 mg 3 times a day. In accordance with the reaction, dosage could be increased every 3-4 days, in increments of not greater than 1 mg daily.
| huisstar | |
1,858,823 | Duxton Dental | Looking for Invisalign Christchurch? Duxton Dental aims to provide the highest standards of dental... | 0 | 2024-05-20T05:30:13 | https://dev.to/duxton_dental/duxton-dental-4no | Looking for [Invisalign Christchurch](https://www.duxtondental.co.nz/invisalign-christchurch)? Duxton Dental aims to provide the highest standards of dental health, function and aesthetics, to ensure your well-being and to promote good health. We offer first-class and innovative dental care with a smile. Get in touch with our friendly team of Christchurch dentists today to make your next appointment.
Our team comprises some of the most respected specialist and general dentists in Christchurch. We’ve brought together an extraordinarily skilled multidisciplinary team of general dentists, hygienists, surgeons and specialists representing the best in their fields.
Get in touch at +6433485488 or via email at info@duxtondental.co.nz. Visit our location at 22 Bartlett Street, Riccarton, Christchurch 8011, New Zealand. Stay connected with us on [Facebook](https://facebook.com/DuxtonDental) and [Instagram](https://instagram.com/duxton.dental) for the latest updates!. | duxton_dental | |
1,873,221 | Buy Ambien Online with Venmo Quick Delivery | click to buy : Buy Xanax Online from usPharma for a care-free and secure experience. Xanax is an... | 0 | 2024-06-01T18:37:33 | https://dev.to/huisstar/buy-ambien-online-with-venmo-quick-delivery-3khl | click to buy : [](https://medxpharma.org/product/xanax-2mg/)
Buy Xanax Online from usPharma for a care-free and secure experience. Xanax is an anxiety agent that is used for the cure of anxiety panic attacks, insomnia, and muscle spasms. Xanax is also known as Alprazolam, contains Methyl, Phenyl, triazolo This medication is also used for Panic attacks and anxiety disorders.
Xanax influences the nervous system of the central part and gives relief to the nerves and brain by boosting GABA neurotransmitter levels.
Buy Xanax Online and get satisfied with Online Shopping with great confidence on the internet with instant delivery in just a few hours. Say goodbye to your anxiety and stress, our website provides an easy solution that lets you buy Xanax at your doorstep.
If you are suffering through anxiety, panic disorders or any other similar conditions, Our quick delivery process makes sure you'll have medication when you need it most. Enjoy relaxation and peace of mind and let know it is only a few hours away, which allows you to focus on your health and rebuild your personality.
The dosage of XANAX used for therapy for PD dosage for PD is 0.5 mg 3 times a day. In accordance with the reaction, dosage could be increased every 3-4 days, in increments of not greater than 1 mg daily.
| huisstar | |
1,873,220 | Dynamic Report Generation in Laravel: Introducing `laravel-dynamic-report-generator` | Are you looking for a way to dynamically generate reports in your Laravel application? Look no... | 0 | 2024-06-01T18:26:04 | https://dev.to/md-sazzadul-islam/dynamic-report-generation-in-laravel-introducing-laravel-dynamic-report-generator-55ee |
Are you looking for a way to dynamically generate reports in your Laravel application? Look no further! Today, I’m excited to introduce `laravel-dynamic-report-generator`, a package that allows you to create dynamic reports with drag-and-drop functionality for selecting table columns and joining multiple tables. Let's dive in and see how you can easily integrate this into your Laravel project.
### Features
- Drag and drop table columns
- Join multiple tables
- Generate dynamic SQL queries
- View and paginate query results
### Installation
To get started with `laravel-dynamic-report-generator`, follow these steps:
1. **Install the package via Composer:**
```bash
composer require devforest/laravel-dynamic-report-generator
```
2. **Publish the configuration file and assets:**
```bash
php artisan vendor:publish --provider="DevForest\ReportGeneratorServiceProvider"
```
3. **Run the migrations:**
```bash
php artisan migrate
```
4. **Add the service provider to `config/app.php` (if not using package discovery):**
```php
'providers' => [
// Other service providers...
DevForest\\ReportGeneratorServiceProvider::class,
],
```
### Usage
Now that you have the package installed, let's walk through how to use it to generate reports.
1. **Navigate to the Report Generator:**
Open your browser and go to `/report-generator` in your Laravel application.
2. **Select Tables and Columns:**
- Drag and drop tables from the list to the workspace.
- Drag and drop columns from the selected tables to include them in the report.
3. **Generate the Query:**
Once you've selected the necessary columns and joins, generate the query. Review and edit the query if needed before executing it.
4. **Execute the Query:**
Click the "Execute" button to run the query and view the results. The results will be displayed in a paginated table.
### Conclusion
With `laravel-dynamic-report-generator`, creating dynamic reports in Laravel has never been easier. Whether you need to generate reports for data analysis, exporting, or just viewing complex data sets, this package has you covered. Install it today and take your Laravel application to the next level!
For more details, check out the [GitHub repository](https://github.com/md-sazzadul-islam/laravel-dynamic-report-generator) and the [documentation](https://github.com/md-sazzadul-islam/laravel-dynamic-report-generator/wiki).
---
Feel free to modify the content according to your needs and include any additional information or features that might be relevant to your users. Happy coding! | md-sazzadul-islam | |
1,873,216 | Greetings | Hello fellow web developers | 0 | 2024-06-01T18:16:29 | https://dev.to/faizan_ishfaqahmed_25a40/greetings-141o | Hello fellow web developers | faizan_ishfaqahmed_25a40 | |
1,873,215 | Introducing the Passport Management System - A Comprehensive Solution for Passport Management | Hello Dev.to community! I'm thrilled to introduce you to my latest project - the Passport Management... | 0 | 2024-06-01T18:13:06 | https://dev.to/md-sazzadul-islam/introducing-the-passport-management-system-a-comprehensive-solution-for-passport-management-37fc |
Hello Dev.to community!
I'm thrilled to introduce you to my latest project - the **Passport Management System**! This Laravel-based application is designed to simplify and streamline the management of passports, medical statuses, payments, and more.
## 🚀 Features
### User Authentication
- Secure login and registration powered by Laravel Passport.
### Passport Management
- Create, update, and manage passport records with ease.
### Medical Status Tracking
- Track medical statuses and reports for passport holders.
### Payments
- Manage payments efficiently and generate detailed payment reports.
### Roles and Permissions
- Utilize fine-grained access control with Spatie Laravel Permission.
### Settings Management
- Easily configure system settings from a user-friendly interface.
## 🛠️ Getting Started
### Prerequisites
- PHP ^8.0.2
- Composer
### Installation Steps
1. **Clone the repository:**
```bash
git clone https://github.com/md-sazzadul-islam/passport-management-system.git
```
2. **Install dependencies:**
```bash
composer install
```
3. **Copy `.env.example` to `.env` and configure your environment variables.**
4. **Generate the application key:**
```bash
php artisan key:generate
```
5. **Create storage link:**
```bash
php artisan storage:link
```
6. **Import SQL:**
```bash
File: passport.sql
```
7. **Start the development server:**
```bash
php artisan serve
```
## 📖 Documentation
For more detailed documentation, please visit the [GitHub Wiki](https://github.com/md-sazzadul-islam/passport-management-system/wiki).
## 🤝 Contribution
I welcome contributions from the community! Whether it's fixing bugs, adding new features, or improving documentation, your help is greatly appreciated. Here's how you can contribute:
## 📝 Feedback
Your feedback is invaluable! If you have any suggestions, feature requests, or encounter any issues, please open an issue on GitHub or leave a comment below.
Thank you for checking out the Passport Management System. I hope you find it useful for your projects. Happy coding!
---
Feel free to customize this post further to match your style or to add more details about the project. | md-sazzadul-islam | |
1,873,214 | 3110. Score of a String | 3110. Score of a String Easy You are given a string s. The score of a string is defined as the sum... | 27,523 | 2024-06-01T18:12:44 | https://dev.to/mdarifulhaque/3110-score-of-a-string-fbl | php, leetcode, algorithms, programming | 3110\. Score of a String
Easy
You are given a string `s`. The **score** of a string is defined as the sum of the absolute difference between the **ASCII** values of adjacent characters.
Return the **score** of `s`.
**Example 1:**
- **Input:** s = "hello"
- **Output:** 13
- **Explanation:**
The ASCII values of the characters in `s` are: `'h' = 104`, `'e' = 101`, `'l' = 108`, `'o' = 111`. So, the score of `s` would be `|104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13`.
**Example 2:**
- **Input:** s = "zaz"
- **Output:** 50
- **Explanation:**
The ASCII values of the characters in `s` are: `'z' = 122`, `'a' = 97`. So, the score of `s` would be `|122 - 97| + |97 - 122| = 25 + 25 = 50`.
**Constraints:**
- <code>2 <= s.length <= 100</code>
- `s` consists only of lowercase English letters.
**Solution:**
```
class Solution {
/**
* @param String $s
* @return Integer
*/
function scoreOfString($s) {
$ans = 0;
for ($i = 1; $i < strlen($s); ++$i) {
$ans += abs(ord($s[$i]) - ord($s[$i - 1]));
}
return $ans;
}
}
```
**Contact Links**
- **[LinkedIn](https://www.linkedin.com/in/arifulhaque/)**
- **[GitHub](https://github.com/mah-shamim)** | mdarifulhaque |
1,873,213 | Adaptar Kotlin 2.0 en aplicaciones Android | Lee este post en inglés aquí. Recientemente, se ha liberado la versión 2.0 de Kotlin, y con ello,... | 0 | 2024-06-01T18:06:06 | https://dev.to/marlonlom/adaptar-kotlin-20-en-aplicaciones-android-1kfa | kotlin, android, compose, k2 | > [Lee este post en inglés aquí.](https://dev.to/marlonlom/adapt-kotlin-20-in-android-applications-3cmk)
Recientemente, se ha liberado la versión 2.0 de Kotlin, y con ello, varios ajustes a los proyectos Android para adaptar o implementar código con esta nueva versión del lenguaje de programación oficialmente soportado por Google para desarrollo móvil Android (Multiplataforma, según las últimas versiones del evento Google I/O).
En este corto artículo, explico mi experiencia migrando de la versión `1.9.23` a la versión `2.0.0`; Esto, debido a las novedades que abarca el uso de esta nueva versión en proyectos que usan Kotlin como lenguaje de programación, y también la posible dificultad de muchos de nosotros los desarrolladores para aplicar migraciones desde versiones de Kotlin muy inferiores a la `1.9.0`.
## Acerca del compilador K2
El compilador K2 es una reimplementación completa del compilador Kotlin original, diseñado para ofrecer mejoras significativas en el desarrollo de aplicaciones Android. Introducido en Kotlin 2.0, K2 aporta varias ventajas, entre las que se destacan: mayor velocidad de compilación, mejoras en rendimiento, y soporte multiplataforma mejorado; Estas ventajas aplicadas a proyectos Android, permiten una reducción en el tamaño de las aplicaciones al generar código más compacto, así como la generación de código nativo lo cual implica mayor rendimiento en las aplicaciones móviles.
### ¿Cómo probar el compilador K2 en Android?
Cabe mencionar, en este apartado se cubre el aspecto de configuración desde el punto de vista de proyectos Android, no mencionaré detalles de KMP, aunque varios de los detalles indicados son fáciles de asimilar si uno ya tiene experiencia en proyectos multiplataforma usando Kotlin.
#### 1. Un nuevo directorio de compilación
Kotlin 2.0 presenta un nuevo directorio de salida de compilación: `.kotlin`. debes agregarlo al archivo `.gitignore` para que su contenido no aparezca en las confirmaciones:
```
# .gitignore
# Kotlin 2.0
.kotlin/
```
#### 2. Aplicar nueva versión de kotlin
Ahora vamos al archivo gradle/libs.versions.toml, en este apartado, se asume se está utilizando Version Catalogs para controlar las dependencias de la aplicación móvil (versiones, plugins, etc.), Se localiza la referencia a la versión de Kotlin, y se cambia a la versión 2.0.0. así:
```
# gradle/libs.versions.toml
[versions]
agp = "8.4.1"
kotlin = "2.0.0"
ksp = "2.0.0-1.0.21"
```
A propósito de la compatibilidad, se debe actualizar también las versiones de las librerías Kotlin symbol processor (KSP) y el plugin gradle para Android (AGP, siglas usadas para referencia), en el snippet anterior se indican las versiones para revisión.
A nivel de librerías, se actualizan también las librerias de kotlin a continuación:
```
# gradle/libs.versions.toml
[libraries]
kotlin-gradle-plugin = "org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.0"
kotlin-serialization-plugin = "org.jetbrains.kotlin:kotlin-serialization:2.0.0"
```
> Nota: hay librerías que, al momento de la redacción del presente artículo, no presentaron inconvenientes en cuanto a cambio de versiones, como `kotlin-coroutines`, `kotlin-serialization`, `kotlin-serialization-json`.
A nivel de plugins, se actualizan también las librerias de kotlin a continuación, esto, tomando en cuenta la referencia de versión ya indicada previamente:
```
# gradle/libs.versions.toml
[plugins]
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
```
Con esto realizado, ejecutar el comando `gradle clean build` o desde Android Studio, hacer build del proyecto.
#### 3. Actualizar el compilador de Compose
Otro aspecto importante en cuanto a la configuración de proyectos Android, especialmente utilizando Jetpack Compose, es el relacionado con el compilador de Compose para Kotlin, el cual es una configuración que permite la transformación de funciones anotadas como `@Composable` en pro de aplicar optimizaciones en la compilación de dichas funciones, ahora, la forma de definir la versión del compilador de compose ha presentado un gran cambio, el cual se describe a continuación.
Anteriormente, se tenia que colocar la versión del compilador de compose dentro del archivo build.gradle del modulo del proyecto gradle que posea las implementaciones Android y que contengan también las implementaciones de Jetpack Compose.
```
/* build.gradle.kts */
…
composeOptions {
kotlinCompilerExtensionVersion = "1.5.3"
}
…
```
Y en caso de utilizar Version Catalogs, se indicaría la versión de la siguiente manera:
```
# gradle/libs.versions.toml
[versions]
compose-compiler = “1.5.3”
…
```
```
/* build.gradle.kts */
…
composeOptions {
kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
}
…
```
Esta iniciativa fue buena en su momento, pero presenta algunos problemas de mantenimiento, ya que se requiere que sea compatible con la versión actual de Kotlin. Es diferente de la versión Compose y el IDE no propuso mejorarla. Cada vez que se actualiza la versión de Kotlin, se tiene que buscar en la documentación de Jetpack Compose en Google la versión compatible del compilador Compose. Kotlin 2.0 soluciona este problema.
Ahora, se aplica en el archivo `gradle/libs.versions.toml` la inclusión de un nuevo plugin de gradle, que se encarga de manejar la versión del compilador de compose mas organizada y ligada a la versión de Kotlin.
```
# gradle/libs.versions.toml
[plugins]
…
kotlin-compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
```
Luego de esta accion, se modifica el archivo `build.gradle.kts` del módulo Android que posea las capacidades de Jetpack Compose, removiendo la configuración `composeOptions. kotlinCompilerExtensionVersion ` y agregando la referencia al plugin `kotlin-compose-compiler` en la sección `plugins { .. }`.
```
/* build.gradle.kts */
…
plugins {
…
alias(libs.plugins.compose.compiler)
}
…
```
Con esto realizado, ejecutar el comando `gradle clean build` o desde Android Studio, hacer build del proyecto o sincronizar.
¡Y eso es todo! Este complemento configurará la versión del compilador Compose según la versión actual de Kotlin.
## Conclusiones
En general, el compilador K2 representa un avance significativo para el desarrollo de aplicaciones Android con Kotlin. Las mejoras en la velocidad, el rendimiento y la extensibilidad lo convierten en una herramienta valiosa para los desarrolladores Android.
Ahora que ya se está volviendo como estándar el uso de Kotlin 2.0.0, Ahora es buen momento para actualizar nuestros aplicativos Android para que estos soporten más de la tecnología que va y va evolucionando en cuando a Kotlin, KMP, Jetpack Compose, y las demás tecnologías que desde Google y desarrolladores de apps y librerias móviles van adaptando para unas apps móviles mas modernas y con mejores prestaciones.
Espero que encuentres esto informativo y útil y que en algún momento puedas seguir estos pasos en tus aplicaciones de Android, en pro de aplicar una buena migración hacia Kotlin 2.0.0.
Gracias por leer, ¡feliz código! 😊
| marlonlom |
1,873,211 | In-Project Python Virtualenvs in Poetry | Poetry is a dependency and package manager for Python. You can list the Poetry configuration with... | 0 | 2024-06-01T17:54:43 | https://dev.to/rudolfolah/in-project-virtualenvs-in-poetry-30km | python, virtualenv, poetry, configuration | Poetry is a dependency and package manager for Python.
* You can list the Poetry configuration with `poetry config --list`
* You can set a Poetry configuration option with `poetry config $setting $value`, for example `poetry config virtualenvs.path /path/to/cache/directory/virtualenvs`
When a Poetry project is created, the default configuration will create a virtualenv in another directory.
Change where the virtualenv is created by adding this `poetry.toml` file to your project before you run `poetry install`:
```
# poetry.toml
[virtualenvs]
create = true
in-project = true
```
The documentation for Poetry advises *not* to check in the `poetry.toml` into version control since it can contain user-specific settings. You can add `poetry.toml` to the `.gitignore` for a repo.
| rudolfolah |
1,873,210 | Django: Generic List and Detail Views | From learn.firstdraft and MDN Django Generic Views Overview Use generic class-based list... | 0 | 2024-06-01T17:44:04 | https://dev.to/samuellubliner/django-generic-list-and-detail-views-3nfc | webdev, python, django | From learn.firstdraft and [MDN Django Generic Views](https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django/Generic_views)
## Overview
- Use generic class-based list views for listing multiple records, and detail views for displaying individual records.
- Extract information from URL patterns and pass it to the view.
- These views reduce the amount of view code needed, streamlining the development process.
- Implement pagination in list views to efficiently handle large datasets.
- Apply these concepts to create pages to view our books and authors, passing data from URLs to the views.
## Book List Page
- Extend the base template `base_generic.html`.
- Display a list of all available book records.
- URL: `catalog/books/`.
- Each book's title is a hyperlink to the associated book detail page.
- Display the author for each book record.
## URL Mapping
Set the path for `books/` in `/catalog/urls.py`.
The `path()` function:
- Defines a pattern to match the `/catalog/books/` URL.
- Calls the view function returned by `views.BookListView.as_view()` if the URL matches.
- Provides a name for this particular URL mapping.
The view function:
- Is implemented as a class, `BookListView`.
- Inherits from Django's generic class-based views.
- Is converted to a view function using the `as_view()` method.
## View (class-based)
Instead of writing the book list view as a regular function-based view (similar to a Rails controller action):
- Queries the database for all books.
- Calls `render()` to pass the list to a specified template.
Using a class-based generic list view (ListView) is preferable:
- Inherits from an existing view.
- The generic view already implements most of the functionality.
- Aligns with Django best practices for a more robust list view with less code, repetition, and maintenance.
In `catalog/views.py`, the generic view:
- Queries the database.
- Renders a template.
The template can access the list of books using a template variable. By default, generic views look for templates in the `/application_name/templates/application_name/the_model_name_list.html` path.
To modify the default behavior:
- Specify a different template file if you need to use multiple views for the same model.
- Use a different template variable name if needed.
- Customize the queryset to filter or change the subset of results returned.
## Overriding methods in class-based views
- It is possible to override some of the class methods, offering more flexibility than just setting the queryset attribute.
- For instance, override `get_context_data()` to pass additional context variables to the template.
Follow this pattern:
- Get the existing context from the superclass.
- Add new context information.
- Return the new context.
See [Built-in class-based generic views Django docs](https://docs.djangoproject.com/en/5.0/topics/class-based-views/generic-display/).
## Creating the List View Template
The generic class-based list view for a Book model in a catalog application expects the template file to be located at `/django-locallibrary-tutorial/catalog/templates/catalog/book_list.html`. This template should extend the base template.
## Conditional execution
Template tags check whether `book_list` has been defined and is not empty.
For more information about conditional operators, see: [Django Docs](https://docs.djangoproject.com/en/5.0/ref/templates/builtins/#if).
## For loops
The template uses template tags to loop and populate the book template variable.
## Accessing variables
- Access the fields using dot notation: `book.field_name`.
## Call functions in the model from within template
- `Book.get_absolute_url()` gets a URL to display the associated detail record.
- Note: There is no way to pass arguments.
- Warning: Be aware of side effects when calling functions in templates. Be sure not to accidentally do something destructive.
## Update the Base Template
To enable the link on all pages, update `/django-locallibrary-tutorial/catalog/templates/base_generic.html` to use `{% url 'books' %}`. The URL mapping for the book detail pages is needed to create hyperlinks to individual books.
## Book detail page
The book detail page displays information accessed using the URL `catalog/book/<id>`.
## URL Mapping
In `/catalog/urls.py`, the 'book-detail' path function defines a URL pattern, associates it with a generic class-based detail view, and assigns it a name. The `<int:pk>` part captures the book ID, where `pk` stands for primary key, uniquely identifying the book in the database.
## Passing additional options in your URL maps
You may pass a dictionary containing additional options to the view.
## View (class-based)
In `catalog/views.py`:
```python
class BookDetailView(generic.DetailView):
model = Book
```
- Create the template at `/django-locallibrary-tutorial/catalog/templates/catalog/book_detail.html`
- The view will pass the Book record's information to the template.
- Access the book's details in the template using the variable named `object` or `book` (the model's name).
## If the record doesn't exist ...
- Generic class-based detail view raises an exception
- Http404
- Resource not found
- This behavior can be customized
## Creating the Detail View Template
For a Book model in an catalog application, the generic class-based detail view expects the template file to be located at `/django-locallibrary-tutorial/catalog/templates/catalog/book_detail.html`.
To create this template:
- The `url` template tag can reverse the 'author-detail' URL and pass it the author instance for the book. Using `get_absolute_url()` is preferred because any necessary changes need to be made only in the author model.
The template should:
- Extend the base template
- Override the content block.
- Use conditional processing and for loops to iterate through lists of objects.
- Access the context fields using dot notation.
Retrieve the set of `BookInstance` records associated with a particular Book, with the `book.bookinstance_set.all()` function.
Django constructs the function
- by lower-casing the ForeignKey model
- followed by `_set`
- Use `all()` to get all records
You cannot use the `filter()` method directly in templates because you cannot specify arguments to functions.
If you don't define an order (on your class-based view or model), there will be errors:
```bash
[date-time] "GET /catalog/books/?page=1 HTTP/1.1" 200 1637
/foo/local_library/venv/lib/python3.5/site-packages/django/views/generic/list.py:99: UnorderedObjectListWarning: Pagination may yield inconsistent results with an unordered object_list: <QuerySet [<Author: Lubiner, Samuel>, <Author: Van Rossum, Guido>, <Author: Torvalds, Linus>]>
allow_empty_first_page=allow_empty_first_page, **kwargs)
```
The paginator object expects an `ORDER BY` clause executed on your underlying database.
## Pagination
- Django has built-in support for pagination
- Incorporated into the generic class-based list views
## Templates
With paginated data, add support to the template to scroll through the results set. To paginate all list views, add this to the base template. The `page_obj` gets all the information about the current page, previous pages, page numbers, etc.
`{{ request.path }}` gets the current page URL for creating the pagination links, independent of the object that we're paginating.
## Book List Page
Create the author detail and list views.
Author list: `catalog/authors/`
Detail view for the author with a primary key field: `catalog/author/<id>`
- After creating the URL mapper for the author list page, update the "All authors" link in the base template.
- After creating the URL mapper for the author detail page, update the book detail view template so the author link points to the new author detail page.
- Call `get_absolute_url()` on the author model.
## See also
- [Built-in class-based generic views](https://docs.djangoproject.com/en/5.0/topics/class-based-views/generic-display/)
- [Generic display views](https://docs.djangoproject.com/en/5.0/ref/class-based-views/generic-display/)
- [Introduction to class-based views](https://docs.djangoproject.com/en/5.0/topics/class-based-views/intro/)
- [Built-in template tags and filters](https://docs.djangoproject.com/en/5.0/ref/templates/builtins/)
- [Pagination](https://docs.djangoproject.com/en/5.0/topics/pagination/)
- [Making queries > Related objects](https://docs.djangoproject.com/en/5.0/topics/db/queries/#related-objects)
| samuellubliner |
1,873,209 | Glam Up My Markup: Beaches Challenge | This is a submission for [Frontend Challenge... | 0 | 2024-06-01T17:41:51 | https://dev.to/minalfatih/glam-up-my-markup-beaches-challenge-5dld | devchallenge, frontendchallenge, css, javascript | _This is a submission for [Frontend Challenge v24.04.17]((https://dev.to/challenges/frontend-2024-05-29), Glam Up My Markup: Beaches_
## What I Built
<!-- Tell us what you built and what you were looking to achieve. -->
## Demo
See the whole website here 👇🏼
https://minalfatih.github.io/Top-Beaches/
It's responsive for mobile and desktop
<!-- Show us your project! You can directly embed an editor into this post (see the FAQ section from the challenge page) or you can share an image of your project and share a public link to the code. -->
## Journey
Edit the html templete by js to add links in header and add icon rating for beaches, I hide the information of the beach so if you hover the picture it will show you the information and put the pictures of beaches in js all this to make the website more interactive and useful, finally i use the animation in css.
<!-- Tell us about your process, what you learned, anything you are particularly proud of, what you hope to do next, etc. -->
<!-- Team Submissions: Please pick one member to publish the submission and credit teammates by listing their DEV usernames directly in the body of the post. -->
<!-- We encourage you to consider adding a license for your code. -->
<!-- Don't forget to add a cover image to your post (if you want). -->
<!-- Thanks for participating! --> | minalfatih |
1,873,208 | Building Chat Applications with OpenAI's GPT-3.5-turbo using Streamlit, Chainlit, and Gradio | In this post, I will walk you through how to create chat applications using OpenAI's GPT-3.5-turbo on... | 0 | 2024-06-01T17:40:22 | https://dev.to/samagra07/building-chat-applications-with-openais-gpt-35-turbo-using-streamlit-chainlit-and-gradio-4g6p | python, opensource, openai, tutorial | In this post, I will walk you through how to create chat applications using OpenAI's GPT-3.5-turbo on three different platforms: Streamlit, Chainlit, and Gradio. I will provide the complete code for each platform and explain how it works.
### Introduction
Chat applications have become an integral part of modern web applications, providing users with instant support and information. With OpenAI's powerful GPT-3.5-turbo model, building an intelligent chatbot is easier than ever. I'll demonstrate how to create a chat interface using three popular Python libraries: Streamlit, Chainlit, and Gradio.
### Prerequisites
Before I begin, ensure you have the following:
- Python installed on your system
- An OpenAI API key (You can get one by signing up on the [OpenAI website](https://www.openai.com/))
### Common Functionality
I will use a common function to interact with the OpenAI GPT-3.5-turbo API. This function will be used in all three implementations.
## Install the required libraries:
```
pip install openai
pip install streamlit
pip install chainlit
pip install gradio
```
### Import the OpenAI library
```python
import openai
```
This line imports the `openai` library, which is required to interact with OpenAI's API. This library provides functions to make API calls to OpenAI's language models.
### Set the OpenAI API key
```python
openai.api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxx"
```
This line sets the API key required to authenticate with OpenAI's API. The API key is a unique identifier that allows access to OpenAI's services. Replace `"sk-xxxxxxxxxxxxxxxxxxxxxxxxxx"` with your actual OpenAI API key.
### Define the function to get a response from OpenAI's model
```python
def get_response(text):
response = openai.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role":"user","content":text}]
)
return response.choices[0].message.content.strip()
```
This block defines a function `get_response` which takes a string `text` as input and returns a response generated by OpenAI's model.
1. **Function Definition:** `def get_response(text):`
- This defines a function named `get_response` that accepts a single parameter `text`.
2. **Create API Request:** `response = openai.chat.completions.create(...)`
- This line makes an API request to OpenAI to generate a completion based on the given input text.
- The `model` parameter specifies which model to use, in this case, `"gpt-3.5-turbo"`.
- The `messages` parameter is a list of message objects. Each object should have a `role` and `content`. Here, it indicates that the user is providing a text input.
3. **Return Response:** `return response.choices[0].message.content.strip()`
- This line extracts the content of the first message from the response and removes any leading or trailing whitespace using `.strip()`.
- `response.choices` is a list of possible completions generated by the model. In this case, we take the first completion (`choices[0]`), then access the `message` and `content` of that message.
### Main block to handle user input and display chatbot responses
```python
if __name__ == "__main__":
while True:
user_input = input("You: ")
if user_input.lower() in ["bye", "exit"]:
break
response = get_response(user_input)
print("Chatbot: ", response)
```
This block is the main part of the script that runs if the script is executed directly.
1. **Check if Script is Main:** `if __name__ == "__main__":`
- This checks if the script is being run as the main module. If it is, the code inside this block will execute.
2. **Infinite Loop:** `while True:`
- This creates an infinite loop that will keep running until explicitly broken out of.
3. **Get User Input:** `user_input = input("You: ")`
- This prompts the user for input and stores it in the `user_input` variable.
4. **Check for Exit Condition:** `if user_input.lower() in ["bye", "exit"]:`
- This checks if the user input is either "bye" or "exit" (in any case). If it is, the loop breaks, ending the program.
5. **Get Response from OpenAI:** `response = get_response(user_input)`
- This calls the `get_response` function with the user's input to get a response from the OpenAI model.
6. **Print Chatbot Response:** `print("Chatbot: ", response)`
- This prints the response from the chatbot to the console.
This script effectively creates a simple chatbot using OpenAI's GPT-3.5-turbo model, allowing for interactive text-based conversations.
## Building Chat Applications with OpenAI's GPT-3.5-turbo using Streamlit, Chainlit, and Gradio.
### 1. Streamlit Implementation
Streamlit is a powerful library for creating web applications with minimal effort. Below is the complete code for a Streamlit chat application.
```python
import streamlit as st
import openai
# Set your OpenAI API key
openai.api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxx"
# Function to get response from OpenAI
def get_response(text):
response = openai.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": text}]
)
return response.choices[0].message.content.strip()
# Streamlit UI
st.title("Chat with OpenAI GPT-3.5-turbo")
user_input = st.text_input("You: ")
if st.button("Send"):
if user_input:
response = get_response(user_input)
st.write(f"Chatbot: {response}")
```
#### Explanation
1. **Import Libraries**: Import `streamlit` and `openai`.
2. **OpenAI API Key**: Set your OpenAI API key.
3. **get_response Function**: Define a function to send user input to the OpenAI API and return the response.
4. **Streamlit UI**: Create a simple UI with a text input box and a button. When the button is clicked, the user's input is sent to the `get_response` function, and the response is displayed.
### 2. Chainlit Implementation
Chainlit is another library that simplifies the creation of web applications. Here’s how to create a chat application using Chainlit.
```python
import chainlit as cl
import openai
# Set your OpenAI API key
openai.api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxx"
# Function to get response from OpenAI
def get_response(text):
response = openai.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": text}]
)
return response.choices[0].message.content.strip()
@cl.on_message
async def main(message: str):
response = get_response(message)
await cl.Message(content=response).send()
```
#### Explanation
1. **Import Libraries**: Import `chainlit` and `openai`.
2. **OpenAI API Key**: Set your OpenAI API key.
3. **get_response Function**: Define the same function to get the response from OpenAI.
4. **Chainlit Event**: Use `@cl.on_message` decorator to define an asynchronous function that processes incoming messages. When a message is received, the function gets a response from OpenAI and sends it back.
### 3. Gradio Implementation
Gradio provides an easy way to create web interfaces. Here’s the complete code for a Gradio chat application.
```python
import gradio as gr
import openai
# Set your OpenAI API key
openai.api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxx"
# Function to get response from OpenAI
def get_response(text):
response = openai.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": text}]
)
return response.choices[0].message.content.strip()
# Gradio interface
def chat_interface(user_input):
response = get_response(user_input)
return response
iface = gr.Interface(
fn=chat_interface,
inputs=gr.inputs.Textbox(lines=2, placeholder="Enter your message here..."),
outputs="text",
title="Chat with OpenAI"
)
iface.launch()
```
#### Explanation
1. **Import Libraries**: Import `gradio` and `openai`.
2. **OpenAI API Key**: Set your OpenAI API key.
3. **get_response Function**: Define the same function to get the response from OpenAI.
4. **Gradio Interface**: Define a function `chat_interface` that takes user input and returns the response from OpenAI. Create a Gradio interface with text input and text output, then launch it.
### Running the Applications
To run these applications, save each code snippet in a separate Python file and execute it.
- **Streamlit**: Save the code in a file, e.g., `streamlit_chat.py`, and run `streamlit run streamlit_chat.py`.
- **Chainlit**: Save the code in a file, e.g., `chainlit_chat.py`, and run `python chainlit_chat.py`.
- **Gradio**: Save the code in a file, e.g., `gradio_chat.py`, and run `python gradio_chat.py`.
Each command will start a local web server, and you can access the chat application via the provided URL.
You can find the complete Github repository _[here](https://github.com/samagra44/openai_chatbot)_
If you find this project helpful, consider giving it a ⭐ star and forking it to contribute or stay updated!
### Conclusion
In this post, I've shown how to create a chat application using OpenAI's GPT-3.5-turbo on three different platforms: Streamlit, Chainlit, and Gradio. Each platform has its strengths, and you can choose the one that best fits your needs. With minimal code, you can create a powerful and interactive chat interface for your users.
Happy coding 😀
--- | samagra07 |
1,869,422 | 【Reducing costs】Automatically remove old docker container image using Artifact Registry cleanup policies | When dealing with docker container images in Google Cloud, Artifact Registry is used as a storage... | 0 | 2024-06-01T17:39:18 | https://dev.to/yukionishi1129/reducing-costs-automatically-remove-old-docker-container-image-using-artifact-registry-cleanup-policies-734 | webdev, devops, googlecloud, cloud | When dealing with docker container images in Google Cloud, Artifact Registry is used as a storage location for them.
However, as you store container images, more and more old images will remain, and you will eventually reach the capacity beyond the free quota.
This costs you more and more money.
However, Google cloud has 'cleanup policies' that automatically deletes old container images.
This article summarises how to use that cleanup policies to automatically remove old container images.
## What is Artifact Registry?
Artifact Registry is a Google Cloud service that can complement and manage docker container images. You can operate and execute applications by linking the images stored here to CloudRun or CloudRun Jobs.
By integrating with services such as Cloud Build, it is also possible to automatically store container images and set up automatic deployment to services like Cloud Run.
There is also a similar service called Container Registry, but this one is deprecated and it is recommended to use Artifact Registry.
[Further information.](https://cloud.google.com/artifact-registry/docs/overview?hl=en)
So, Artifact Registry is required when dealing with container images in Google Cloud.
### Artifact Registry pricing
As for the pricing that you may be concerned about, the configurations are categorized into the following three types.
- Storage
- Data transfer
- Vulnerability scanning
Data transfer is free f charge within the same location.
Storage is what my be charged for here.
Up to 0.5GB of capacity is free, but beyond that it costs about $0.10 per month in 1GB increments.
[Further information.](https://cloud.google.com/artifact-registry/pricing?hl=en)
In my case, I use three kind of container images, a image's capacity is 11MB. So, all of my container image's capacity is 30~50MB. It is not over 0.5GB within free.
In my case, I run about three container images, which are about 11MB each, so all together are about 30~50MB. I never exceed the free quota of 0.5MB.
However, if Artifact Registry is not specifically configured, the old container image will remain after each reflection of the latest container image.
As these unused images accumulate, they exceed 0.5GB by leeway.
So old container images need to be deleted, but I would like to be automatic.
It is the cleanup policies that can do this.
## What's cleanup policies?
Cleanup policy is a function that automatically deletes container images, etc, stored in the Artifact Registry based on pre-defined content.
[Further information.](https://cloud.google.com/artifact-registry/docs/repositories/cleanup-policy?hl=en)
### delete policy and conditional keep policy
The cleanup policy is designed to set two types.
- **delete policy**
- **conditional keep policy**
As the name suggests, these set the conditions for deleting and retaining images respectively.
It is important to note that if only a "condition keep policy" is set, nothing is deleted. Container images will not be performed unless a "delete policy" is set.
So, for example, "You want to saved latest two container image, delete others"
So, for example, if you want to "keep the two most recent container images and delete everything else", the setting must be set up as follows.
- delete policy: **Remove images with or without tags.**
- condition keep policy: **Only the two most recent versions are retained.**
I write after about especially methods.
Specific settings are described below.
### Constraints
Cleanup policies have the following restrictions.
- Deletions and retentions triggered by the clean-up policy are performed once per day (it is not known at what point in time they are performed).
- Deletions triggered by delete policies are up to 30,000 per repository, per day
- Up to 10 clean-up policies per repository
It is important to note that **the clean-up policy is only executed once a day.**
It is also not clear at what time of the day it is executed, so depending on the timing, container images may not be removed.
If you have automated CloudBuild or Github Actions to reflect the main repository in the ArtifactRegistry every time it is updated, and you reflect it many times a day, in some cases the container image may remain undeleted.
The policy will be executed again the next day and the image will be deleted, but be aware that if the storage capacity is squeezed while it is not deleted, the billing amount may increase.
## How to set up automatically deletion
### Condition of automatically deletion
In this case, the container image is set to be automatically deleted with the following content.
- Only the two most recent container images are retained, all other images are deleted.
Therefore, set up a "delete policy" and "keep condition policy" with the following details.
- delete policy: remove images with or without tags.
- condition keep policy: only the two most recent versions are retained.
### How to set up
Go to Google Cloud and navigate to the Artifact Registry page.
A list of repositories will appear, select the target repository.
Click on "EDIT REPOSITORY"
Scroll to below, select "Cleanup policies" and "Delete artifacts".
From here, set up "delete policy" and "keep condition".
Click on "ADD A CLEANUP POLICY".
First, set "delete policy".
Fill in "name" and select "Conditional delete".
Leave the "Tag state" as "Any tag state".
Finally, click on "DONE" in the bottom right-hand corner.
Second, "condition keep policy".
Click on "ADD A CLEANUP POLICY" again to create a new policy.
Fill in "name" and select "Keep most recent versions" as the policy types.
"Keep points" should be "2".
Finally, click on "DONE" in the bottom right-hand corner.
Finally, click on the "Update" button at the bottom and you are done.
The timing of when the policy is executed is random, but after some time only the two latest versions of the images in the repository will be available.
## Summary.
"Cleanup policies" can now be set to automatically remove old container images.
If you use Artifact Registry, set this to avoid unnecessary charges. | yukionishi1129 |
1,873,207 | 🌟 Discover 5 Must-Have VSCode Extensions You Haven't Tried Yet | Hey there! Yes.. this is one of those posts, but.. I promise you're not going to find the generic... | 0 | 2024-06-01T17:38:28 | https://dev.to/g3nt/discover-5-must-have-vscode-extensions-you-havent-tried-yet-185m | vscode, webdev, productivity, javascript | _Hey there! Yes.. this is one of those posts, but.. I promise you're not going to find the generic stuff like "Prettier" here, don't get me wrong, while its essential, we kinda all know & have it. The purpose of this post is to try and find those hidden gems. I hope this helps :))_
## 1. Error Lens
Think of this extension like your "Problems" tab within the VSCode terminal but on.. steroids, its basically going to show and highlight any issues in your code/syntax right at the specific line on the editor.
##2. Console Ninja
We've all been sick and tired of going back and forth between tabs to only read the logs (console logs).. So the Console Ninja team said enough's enough and decided to instead showcase us the console log outputs and runtime errors directly in our editor.
##3. Pretty TypeScript Errors
Look, as much as we love TS (not really?) we can surely admit seeing those long errors where one of the 43 nested types doesnt match isnt as optimal as we'd like, not to mention those error messages that can only be deciphered from Harvard PhD professors (and Matt Pocock). Luckily for us this extension saves the day by simplifying everything for us and making life easier.
##4. Hungry Delete
Remember selecting all that empty space and then having to delete it, or even worse having to press backspace 10-15 times to do that? Well, this extension makes sure that you dont have to go trough that again, but instead take care of that emptyspace or tab by simply pressing CTRL+BACKSPACE
##5. Add gitignore
At some point, we'll all have to create a .gitignore file and thats a fact, so, why not speed up the process and have a extension specifically built to help you create it faster with variety of templates to choose from?
 | g3nt |
1,873,107 | Creating In-Video Search | In-video search is ability to search for a specific content within a video. This can include... | 0 | 2024-06-01T17:33:52 | https://suyashthakurblog.hashnode.dev/creating-an-in-video-search-system | machinelearning, ai, tutorial, datascience | In-video search is ability to search for a specific content within a video. This can include searching for particular words spoken, objects shown or description of a scene.
With the current advancement in transformers the process of in-video search have become more accurate and fairly simple. Although most of the transformers doesn’t have a joint embedding space for multiple modalities but there are few models like Meta’s ImageBind that a joint embedding space between text, image, audio, depth, thermal and IMU, or OpenAI’s CLiP model have joint embedding space between text and image. We can use these models to create a relatively quick and accurate in-video service.
## What data does a video consist of ?
A typical video would have the following data with them -:
1. **Frames -:** A video is basically a series of the frames. Some of these frames are complete frames called i-frames and others will be partial frames, also known as p-frames and b-frames, which contain only the changes from the previous frame.
2. **Audio -:** A video also might have a audio channels. These channels can contain different types of audio tracks, such as dialogue, music, and sound effects.
3. **Subtitles/Transcript -:** Many videos include subtitle or closed caption tracks or the transcript could be derived from the audio. This data is important for us to query a dialogue in the video.
We will process these data independently using different techniques.
## Processing Frames
Typically frames in a video is of three types -:
1. **i-frame** -: They are complete, self-contained frames that do not rely on other frames for decoding.
2. **p-frame** -: These frames rely on previous frames for decoding. They are compressed by only storing the differences between the current frame and the previous frame.
3. **b-frame** -: These frames rely on both previous and future frames for decoding. They are compressed by storing the differences between the current frame and the previous frame, as well as the differences between the current frame and the next frame.
For our use-case we will rely on i-frame since they serve as the reference point for other type of frames. We will create vector representation of p-frames and store it in our vector DB with metadata such as timestamp of the frame using the following steps -:
1. **Extract i-frames** -: We can use ffmpeg to extract i-frames of a video.
2. **Discard similar i-frames** -: Often, two i-frames can be very similar to each other. Indexing these similar frames in our vector DB would waste resources. We will discard similar frames by calculating the Structural Similarity Index (SSIM) between two frames. SSIM measures the similarity between two images using luminance, contrast, and structure. For more information, use this [link](https://www.notion.so/c57e4bd5df5f4c9ab6f5cf9343b75e0e?pvs=21).
3. **Generate Embeddings**: Once we have discarded the similar i-frames, we will pass the remaining images to the ImageBind model to generate the associated embeddings and store them in our vector DB.
## Processing Audio
Processing audio is optional and often does not significantly enhance results, as audio typically doesn't provide unique information beyond what is already available in video frames or transcripts. However, if your use case benefits from audio data, this method can be utilized.
To process audio, the first step is to divide it into smaller clips. Instead of clipping the audio at constant intervals, which might not yield the best results, we will smartly segment the audio so that each chunk retains complete contextual information.
Before that we will need to get familiar with two terms -:
1. **Spectral Contrast -:** The audio is divided into different sections based on pitch. Imagine dividing the music into high-pitch, middle-pitch, and low-pitch parts. In each section, we look for the loudest parts (peaks) and the quietest parts (valleys). We measure how big the difference is between the loudest and quietest parts in each section. This difference is the "contrast.” We will then calculate the mean of spectral contrast of different sections.
2. **RMS Energy -:** RMS (Root Mean Square) Energy is a measure of the power or loudness of the audio signal. This gives us an idea of how much energy the audio signal has, which correlates to its perceived loudness. It is calculated using the following formulae -:
{% katex %}
\text{RMS} = \sqrt{\frac{1}{N} \sum_{i=1}^{N} x_i^2}
{% endkatex %}
We will process each frame (a continuous segment of the audio signal), calculating and normalising its spectral contrast and RMS energy. By comparing these features with the previous frame, we will determine whether it belongs to the same clip or a new one. A new clip will be created if the following condition is met.
{% katex %}
(SC_2 - SC_1) +(RMS_2 - RMS_1) > Threshold
{% endkatex %}
Once we have the clips we will create the embeds associated with it using ImageBind and store it in out vector database along with the metadata like timestamp of the clip.
## Processing Text Data
Video data may include a subtitle file, or a transcript can be generated from the video. Working with text data is typically simpler. To preserve context and minimize information loss, we'll segment the text data with some overlap. Then, we'll generate the embeddings using ImageBind and store them in VectorDB, marking each with its corresponding timestamp.
## Querying For Video Clip
The process of querying a video clip begins with a prompt provided by the user. Upon receiving the query, we follow these steps:
1. We generate the embed for the prompt and query our vector database to find the closest match. This could be a text, frame, or audio embed.
2. If the embed is text-based, we calculate the cosine similarity of the next and previous text embeddings. We continue to iterate in both directions until the cosine similarity falls below a certain threshold. This threshold can be calculated dynamically (I created an npm package for this purpose. [You can check it out here](https://www.npmjs.com/package/cosine-similarity-threshold)). The start time of the first chunk becomes the start time of the video clip, while the end time of the last chunk becomes the end time.
3. If the embed is audio-based, the process is more straightforward. We simply use the start time of the audio clip as the start of the video, and the end time of the audio clip as the end of the video.
4. If the embed is of a frame, then the timestamp of the previous frame in vectorDB is the start time of the video clip, and the timestamp of the next frame is the end time of the video clip.
5. Once we have the start and end times for the video clips, we will generate the clip from the original video and provide the output.
In conclusion, with the help of advanced transformer models like ImageBind, creating a reliable and efficient in-video search service is more attainable than ever. By processing and embedding different data modalities from videos - frames, audio and text - we can create a comprehensive search system that caters to a wide array of user queries. Remember, the process highlighted in this article is a guide - the thresholds, processing techniques, and models can be tweaked and optimized as per your specific use case. Happy coding! | suyashthakur |
1,873,201 | Angular CDK Tutorial: Copy to Clipboard | When we build things with Angular, we often find ourselves needing to do stuff that we see on the web... | 26,397 | 2024-06-01T17:33:12 | https://briantree.se/angular-cdk-tutorial-copy-to-clipboard/ | angular, angularcdk, angulardevelopers, webdev | When we build things with Angular, we often find ourselves needing to do stuff that we see on the web or in other applications every day. Like copying text to the clipboard for example. Something like that could take a little work to pull off if we were creating it from scratch. But one of the benefits of working with a framework like angular is that many of these common application concepts have already been figured out for us and made available by either the framework itself or, in this case the [Component Dev Kit (a.k.a., CDK)](https://material.angular.io/cdk/categories). So, in this example we’ll see just how easy this task is thanks to the CDK. Alright, let’s get to it.
{% embed https://www.youtube.com/embed/yguZOK0OYzc %}
## The Demo Application
For the example in this post, we’ll be working with [this demo application](https://stackblitz.com/edit/stackblitz-starters-b8gbzr?file=src%2Fslider%2Fshare%2Fshare.component.html), Petpix. It’s an app where people can share cool images of their pets.
Here, we’re looking at an image gallery where we can navigate between the images. In the upper right corner of each image, there’s a share button. When we click this button, we get a form containing a message and a link to this image. We also have a copy button.
<div>
<img src="https://briantree.se/assets/img/content/uploads/2024/06-01/demo-1.gif" alt="Example of a demo pet image gallery application built with Angular" width="592" height="622" style="width: 100%; height: auto;">
</div>
Right now, the copy button isn’t wired up to do anything, so when we click it nothing happens. And, it’s probably pretty obvious, but we want this button to copy the contents of the form field to the user’s clipboard so that they can then paste it in a text message, or an email, or something else.
Well, this is exactly what we’re going to do in this example, and it’s going to be pretty easy to do too.
## Installing the Angular CDK
Ok, since we’re using the [CDK](https://material.angular.io/cdk/categories), we‘ll need to make sure before we do anything else, we install it using the following command.
```shell
npm i @angular/cdk
```
Now once we have it installed, we will be able to use the [Clipboard Module](https://material.angular.io/cdk/clipboard/overview) to do exactly what we need. And, in particular, we will be using the [`cdkCopyToClipboard`](https://material.angular.io/cdk/clipboard/api#CdkCopyToClipboard) directive on our copy button.
Ok, let’s look at some code.
## The Existing Code
Let's start by looking at the template for the [slider component](https://stackblitz.com/edit/stackblitz-starters-b8gbzr?file=src%2Fslider%2Fslider.component.html) which contains the markup and logic for our image gallery. Within this template we have a [switch statement](https://angular.dev/guide/templates/control-flow#switch-block---selection) that is used to determine which image and content to show.
#### slider.component.html
```html
<div ... class="image">
@switch(selectedImage()) {
@case(1) {
...
}
@case(2) {
...
}
@case(3) {
...
}
@case(4) {
...
}
}
</div>
```
For each of the images, we have a share component that wraps the image. This share component has a “message” [input](https://angular.dev/guide/signals/inputs) that we are using to pass a message and a URL. Now in a real application this would be a real link to the image itself but for this example, it just links to this demo.
```html
<app-share message="Hey, check out this cool image of a dog on a surfboard: https://stackblitz.com/edit/stackblitz-starters-ul93wc?file=src%2Fslider%2Fslider.component.html">
<img src="/assets/2.jpg" alt="A dog on a surfboard" />
</app-share>
```
Next, let’s take a look at the [share component](https://stackblitz.com/edit/stackblitz-starters-b8gbzr?file=src%2Fslider%2Fshare%2Fshare.component.html).
Here we have the share button, and it’s displayed when a “messageVisible” [signal](https://angular.dev/guide/signals#writable-signals) is false. When this button is clicked, it sets the value of this “messageVisible” [signal](https://angular.dev/guide/signals#writable-signals) to true.
#### share.component.html
```html
@if (!messageVisible()) {
<button (click)="messageVisible.set(true)">
Share Image
</button>
} @else {
...
}
```
Then, when that [signal](https://angular.dev/guide/signals#writable-signals) is true, the “message” region will be displayed which contains the textbox with our message in it, and the button that we will use to copy this value to the clipboard.
```html
@if (!messageVisible()) {
...
} @else {
<div class="message">
<input type="text" [value]="message()" readonly/>
<button>Copy</button>
</div>
}
```
## Adding “Copy to Clipboard” Functionality with the Angular CDK Clipboard Module
Now, before we can use the [directive](https://material.angular.io/cdk/clipboard/api#CdkCopyToClipboard), we need to import the [module](https://material.angular.io/cdk/clipboard/overview) into our component, so let’s switch to the [typescript](https://stackblitz.com/edit/stackblitz-starters-b8gbzr?file=src%2Fslider%2Fshare%2Fshare.component.ts). Then, within our imports array, let’s add the ClipboardModule, and we need to be sure that it gets imported properly from the CDK.
#### share.component.ts
```typescript
import { ClipboardModule } from '@angular/cdk/clipboard';
@Component({
selector: 'app-share',
...
imports: [ ..., ClipboardModule ]
})
```
Ok, now let’s switch back over to the [template](https://stackblitz.com/edit/stackblitz-starters-b8gbzr?file=src%2Fslider%2Fshare%2Fshare.component.html). On the copy button, let’s add the [`cdkCopyToClipboard`](https://material.angular.io/cdk/clipboard/api#CdkCopyToClipboard) directive. This directive requires a text value to be passed as an [input](https://angular.dev/guide/signals/inputs), so we’ll pass it our “message” [input](https://angular.dev/guide/signals/inputs) value from this share component.
#### share.component.html
```html
<button [cdkCopyToClipboard]="message()">
Copy
</button>
```
And that’s it, pretty easy right? That’s all we need to make it so that this button will now copy our message value to the clipboard.
So, let’s save and see how it works.
We’ll hit the share button, then the copy button, and at this point it’s hard to know if it worked or not. So, we’ll paste the contents of our clipboard in the textarea at the bottom of the page.
<div>
<img src="https://briantree.se/assets/img/content/uploads/2024/06-01/demo-2.gif" alt="Example of a button using the Angular CDK Clipboard Module to copy a message to the users' clipboard" width="702" height="1062" style="width: 100%; height: auto;">
</div>
And there it is, pretty cool right?
### Adding Logic After the Value Has Been Copied to the Clipboard with the “Copied” Event
So that was cool and easy to do, but there’s even more we can do with this directive. Let’s say we want to switch the button text from the word “copy” to “copied” once the value has been copied to the clipboard. Well, we can do this with the `cdkCopyToClipboardCopied` event that gets emitted from the [`cdkCopyToClipboard`](https://material.angular.io/cdk/clipboard/api#CdkCopyToClipboard) directive once the value is copied.
To do this, let’s add a “copied” [signal](https://angular.dev/guide/signals#writable-signals) that we’ll use to toggle the text in the button. Let’s give it an initial value of false.
#### share.component.ts
```typescript
import { ..., signal } from "@angular/core";
@Component({
selector: 'app-share',
...
})
export class ShareComponent {
...
protected copied = signal(false);
}
```
Ok now let’s switch back to the template and let’s add the `cdkCopyToClipboardCopied` event to the copy button with the directive. When the event fires, let’s set our “copied” [signal](https://angular.dev/guide/signals#writable-signals) value to true.
#### share.component.html
```html
<button
[cdkCopyToClipboard]="message()"
(cdkCopyToClipboardCopied)="copied.set(true)">
Copy
</button>
```
So that will change the value of that property, now we need to swap out the label.
Let’s switch to string interpolation here and we’ll use a ternary operator with our “copied” signal to display the word “copied” when it’s true, and “copy” when it’s false.
```html
<button
[cdkCopyToClipboard]="message()"
(cdkCopyToClipboardCopied)="copied.set(true)">
{{ copied() ? 'Copied!' : 'Copy' }}
</button>
```
Ok, there we go, now let’s save and try this out.
We’ll click the share button and then we’ll click on the copy button. Now, the button label should switch from “Copy” to “Copied!”. And when we paste, we should still see that the value is properly copied to our clipboard as it was before.
<div>
<img src="https://briantree.se/assets/img/content/uploads/2024/06-01/demo-3.gif" alt="Example of a button using the Angular CDK Clipboard Module to copy a message to the users' clipboard and using the cdkCopyToClipboardCopied event to update the user interface once the value has been copied" width="700" height="1062" style="width: 100%; height: auto;">
</div>
## Conclusion
So, how easy was all of that? Thanks to the folks who work on the [Angular CDK](https://material.angular.io/cdk/categories), we have a really easy way to copy stuff to our clipboard with the [Clipboard Module](https://material.angular.io/cdk/clipboard/overview). And now you know how to use it!
Now there are many more features available in the [Angular CDK](https://material.angular.io/cdk/categories) so be on the lookout for more posts in the future. Also, check out [my YouTube channel](http://www.youtube.com/@briantreese) where you’ll find more [videos on the CDK](https://www.youtube.com/playlist?list=PLp-SHngyo0_iQ9x2X88s5VMSAjyf4cM4C) and [Angular in general](https://www.youtube.com/playlist?list=PLp-SHngyo0_hY0GY_vFfpgRv2Y0R7TUXh).
## Want to See It in Action?
Check out the demo code and examples of these techniques in the in the Stackblitz example below. If you have any questions or thoughts, don’t hesitate to leave a comment.
{% embed https://stackblitz.com/edit/stackblitz-starters-ul93wc?ctl=1&embed=1&file=src%2Fslider%2Fshare%2Fshare.component.html %}
---
## Found This Helpful?
If you found this article helpful and want to show some love, you can always [buy me a coffee!]( https://buymeacoffee.com/briantreese)
| brianmtreese |
1,873,200 | Real-Time Notifications with WebSocket in Spring Boot | In modern web applications, real-time communication between the server and clients is becoming... | 0 | 2024-06-01T17:22:54 | https://dev.to/fullstackjava/real-time-notifications-with-websocket-in-spring-boot-40ao | webdev, programming, tutorial, java | In modern web applications, real-time communication between the server and clients is becoming increasingly important. Traditional HTTP request-response communication is not suitable for scenarios where data needs to be pushed from the server to clients in real-time. This is where WebSocket comes into play. WebSocket is a protocol that provides full-duplex communication channels over a single TCP connection, allowing for bi-directional data flow between the server and clients.
Spring Boot provides excellent support for WebSocket through its `spring-websocket` module. In this blog post, we'll explore how to build a real-time notification system using WebSocket in a Spring Boot application.
## Prerequisites
Before we dive in, ensure you have the following:
- Basic knowledge of Spring Boot and Java
- Understanding of the WebSocket protocol
- Familiarity with front-end technologies like JavaScript and HTML
## Setting Up the Spring Boot Application
### 1. Add Dependencies
First, create a new Spring Boot project or add the following dependencies to your existing `pom.xml`:
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
```
### 2. Enable WebSocket Support
Enable WebSocket support by adding the `@EnableWebSocketMessageBroker` annotation to your main application class or a dedicated configuration class.
## Creating the WebSocket Configuration
### 1. Define WebSocket Configuration
Create a configuration class to set up WebSocket:
```java
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/websocket").withSockJS();
}
}
```
### 2. Explanation
- `@EnableWebSocketMessageBroker` enables WebSocket message handling.
- `setApplicationDestinationPrefixes` maps incoming messages to `@MessageMapping` methods.
- `enableSimpleBroker` sets up an in-memory message broker.
## Implementing the WebSocket Handler
### 1. Create a Message Controller
Create a controller to handle incoming WebSocket messages:
```java
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;
@Controller
public class NotificationController {
@MessageMapping("/send")
@SendTo("/topic/notifications")
public String sendNotification(String message) {
return message;
}
}
```
### 2. Explanation
- `@MessageMapping("/send")` maps to `/app/send`.
- `@SendTo("/topic/notifications")` sends the message to `/topic/notifications`.
## Sending Notifications
### 1. Inject SimpMessagingTemplate
Inject `SimpMessagingTemplate` to send messages:
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Service;
@Service
public class NotificationService {
@Autowired
private SimpMessagingTemplate template;
public void sendNotification(String message) {
template.convertAndSend("/topic/notifications", message);
}
}
```
### 2. Explanation
- `convertAndSend` sends a message to the specified destination.
## Building the Front-End
### 1. Create HTML File
Create an HTML file with a WebSocket connection:
```html
<!DOCTYPE html>
<html>
<head>
<title>WebSocket Notifications</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/sockjs-client/1.5.1/sockjs.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/stomp.js/2.3.3/stomp.min.js"></script>
</head>
<body>
<div id="notifications"></div>
<script>
var socket = new SockJS('/websocket');
var stompClient = Stomp.over(socket);
stompClient.connect({}, function(frame) {
stompClient.subscribe('/topic/notifications', function(notification) {
var notifications = document.getElementById('notifications');
var message = document.createElement('p');
message.appendChild(document.createTextNode(notification.body));
notifications.appendChild(message);
});
});
</script>
</body>
</html>
```
### 2. Explanation
- Connect to the WebSocket endpoint.
- Subscribe to `/topic/notifications`.
- Display received messages in the browser.
## Example Implementation
Here is a complete example implementation with the server-side and client-side components we discussed.
### Server-Side Code
#### `WebSocketConfig.java`
```java
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/websocket").withSockJS();
}
}
```
#### `NotificationController.java`
```java
@Controller
public class NotificationController {
@MessageMapping("/send")
@SendTo("/topic/notifications")
public String sendNotification(String message) {
return message;
}
}
```
#### `NotificationService.java`
```java
@Service
public class NotificationService {
@Autowired
private SimpMessagingTemplate template;
public void sendNotification(String message) {
template.convertAndSend("/topic/notifications", message);
}
}
```
### Client-Side Code
#### `index.html`
```html
<!DOCTYPE html>
<html>
<head>
<title>WebSocket Notifications</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/sockjs-client/1.5.1/sockjs.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/stomp.js/2.3.3/stomp.min.js"></script>
</head>
<body>
<div id="notifications"></div>
<script>
var socket = new SockJS('/websocket');
var stompClient = Stomp.over(socket);
stompClient.connect({}, function(frame) {
stompClient.subscribe('/topic/notifications', function(notification) {
var notifications = document.getElementById('notifications');
var message = document.createElement('p');
message.appendChild(document.createTextNode(notification.body));
notifications.appendChild(message);
});
});
</script>
</body>
</html>
```
## Conclusion
In this blog post, we learned how to implement real-time notifications using WebSocket in a Spring Boot application. We covered the setup, configuration, and implementation of the server-side and client-side components. WebSocket provides a powerful mechanism for real-time communication, enabling applications to deliver timely and relevant notifications to users.
By following this guide, you can create a robust real-time notification system that enhances user experience and engagement in your web applications. | fullstackjava |
1,873,199 | A Comprehensive Guide to Multiple Database Configuration for Microservices in Spring Boot | Multiple Database Configuration for Microservices in Spring Boot: A Comprehensive Guide In... | 0 | 2024-06-01T17:22:11 | https://dev.to/fullstackjava/a-comprehensive-guide-to-multiple-database-configuration-for-microservices-in-spring-boot-1la4 | webdev, programming, database, springboot | # Multiple Database Configuration for Microservices in Spring Boot: A Comprehensive Guide
In modern microservice architectures, it's common to have services that need to interact with multiple databases. This could be due to various reasons such as legacy system integration, different types of data storage needs, or simply for optimizing performance. Spring Boot, with its flexible configuration and powerful data access libraries, makes it straightforward to configure multiple databases. In this comprehensive guide, we'll explore how to set up and manage multiple database connections in a Spring Boot microservice.
## Table of Contents
1. Introduction
2. Why Use Multiple Databases?
3. Setting Up a Spring Boot Project
4. Configuring Multiple Data Sources
5. Creating Data Source Configuration Classes
6. Defining Entity Managers
7. Creating Repositories
8. Testing the Configuration
9. Conclusion
## 1. Introduction
Microservices often need to interact with various databases. Each microservice might require a different type of database, such as an SQL database for transactional data and a NoSQL database for unstructured data. Spring Boot provides excellent support for configuring and managing multiple data sources, making it an ideal choice for modern microservice architectures.
## 2. Why Use Multiple Databases?
There are several reasons why you might need to use multiple databases in a microservice:
- **Legacy System Integration:** Integrating with existing databases that are part of legacy systems.
- **Optimized Performance:** Using different databases optimized for specific types of data (e.g., relational vs. non-relational).
- **Data Segregation:** Separating data for security, compliance, or organizational reasons.
- **Scalability:** Distributing the data load across different databases to improve performance.
## 3. Setting Up a Spring Boot Project
To get started, create a new Spring Boot project. You can use Spring Initializr or your preferred IDE to set up the project.
### Maven Dependencies
In your `pom.xml`, include dependencies for Spring Data JPA and the databases you will use (e.g., H2 for in-memory, PostgreSQL, MySQL, etc.).
```xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Add other database dependencies as needed -->
</dependencies>
```
## 4. Configuring Multiple Data Sources
In the `application.yml` or `application.properties` file, configure the connection properties for each database.
### application.yml
```yaml
spring:
datasource:
primary:
url: jdbc:h2:mem:primarydb
driver-class-name: org.h2.Driver
username: sa
password: password
secondary:
url: jdbc:postgresql://localhost:5432/secondarydb
driver-class-name: org.postgresql.Driver
username: postgres
password: password
jpa:
primary:
database-platform: org.hibernate.dialect.H2Dialect
hibernate:
ddl-auto: update
secondary:
database-platform: org.hibernate.dialect.PostgreSQLDialect
hibernate:
ddl-auto: update
```
## 5. Creating Data Source Configuration Classes
Next, create separate configuration classes for each data source.
### Primary Data Source Configuration
```java
package com.example.config;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
@Configuration
@EnableJpaRepositories(
basePackages = "com.example.primary.repository",
entityManagerFactoryRef = "primaryEntityManagerFactory",
transactionManagerRef = "primaryTransactionManager"
)
public class PrimaryDataSourceConfig {
@Bean(name = "primaryDataSource")
@ConfigurationProperties(prefix = "spring.datasource.primary")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
@Bean(name = "primaryEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(
@Qualifier("primaryDataSource") DataSource dataSource) {
LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
em.setDataSource(dataSource);
em.setPackagesToScan(new String[] { "com.example.primary.entity" });
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
em.setJpaVendorAdapter(vendorAdapter);
return em;
}
@Bean(name = "primaryTransactionManager")
public PlatformTransactionManager primaryTransactionManager(
@Qualifier("primaryEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
return new JpaTransactionManager(entityManagerFactory);
}
}
```
### Secondary Data Source Configuration
```java
package com.example.config;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
@Configuration
@EnableJpaRepositories(
basePackages = "com.example.secondary.repository",
entityManagerFactoryRef = "secondaryEntityManagerFactory",
transactionManagerRef = "secondaryTransactionManager"
)
public class SecondaryDataSourceConfig {
@Bean(name = "secondaryDataSource")
@ConfigurationProperties(prefix = "spring.datasource.secondary")
public DataSource secondaryDataSource() {
return DataSourceBuilder.create().build();
}
@Bean(name = "secondaryEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean secondaryEntityManagerFactory(
@Qualifier("secondaryDataSource") DataSource dataSource) {
LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
em.setDataSource(dataSource);
em.setPackagesToScan(new String[] { "com.example.secondary.entity" });
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
em.setJpaVendorAdapter(vendorAdapter);
return em;
}
@Bean(name = "secondaryTransactionManager")
public PlatformTransactionManager secondaryTransactionManager(
@Qualifier("secondaryEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
return new JpaTransactionManager(entityManagerFactory);
}
}
```
## 6. Defining Entity Managers
Define entity classes for each database. Make sure to place them in the respective packages specified in the configuration classes.
### Primary Database Entity
```java
package com.example.primary.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class PrimaryEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
// getters and setters
}
```
### Secondary Database Entity
```java
package com.example.secondary.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class SecondaryEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String description;
// getters and setters
}
```
## 7. Creating Repositories
Create repository interfaces for each database, ensuring they are placed in the correct packages as configured.
### Primary Repository
```java
package com.example.primary.repository;
import com.example.primary.entity.PrimaryEntity;
import org.springframework.data.jpa.repository.JpaRepository;
public interface PrimaryRepository extends JpaRepository<PrimaryEntity, Long> {
}
```
### Secondary Repository
```java
package com.example.secondary.repository;
import com.example.secondary.entity.SecondaryEntity;
import org.springframework.data.jpa.repository.JpaRepository;
public interface SecondaryRepository extends JpaRepository<SecondaryEntity, Long> {
}
```
## 8. Testing the Configuration
Finally, create a simple REST controller to test the setup. This controller will use both repositories to perform CRUD operations.
### Sample Controller
```java
package com.example.controller;
import com.example.primary.entity.PrimaryEntity;
import com.example.primary.repository.PrimaryRepository;
import com.example.secondary.entity.SecondaryEntity;
import com.example.secondary.repository.SecondaryRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {
@Autowired
private PrimaryRepository primaryRepository;
@Autowired
private SecondaryRepository secondaryRepository;
@GetMapping("/test")
public String test() {
PrimaryEntity primaryEntity = new PrimaryEntity();
primaryEntity.setName("Primary Entity");
primaryRepository.save(primaryEntity);
SecondaryEntity secondaryEntity = new SecondaryEntity();
secondaryEntity.setDescription("Secondary Entity");
secondaryRepository.save(secondaryEntity);
return "Entities saved!";
}
}
```
### Running the Application
Run | fullstackjava |
1,873,159 | How AI And Data Science Are Revolutionizing Industry Operations | Wanna become a data scientist within 3 months, and get a job? Then you need to check this out !... | 0 | 2024-06-01T17:19:25 | https://thedatascientist.com/how-ai-and-data-science-are-revolutionizing-industry-operations/ | ai, datascience, operations | Wanna become a data scientist within 3 months, and get a job? Then you need to check this out !
Artificial intelligence (AI) and data science are at the forefront of a technological revolution, transforming industry operations across the globe. With the proliferation of data and the advancement of algorithms, these technologies are enabling businesses to optimize processes, enhance decision-making, and deliver unprecedented value.
The introduction of [public cloud services](https://us.ovhcloud.com/public-cloud/what-public-cloud/) is a key factor enabling this shift. These services offer adaptable and scalable infrastructures that facilitate the application of data science and artificial intelligence.
This enables enterprises of all sizes to have access to advanced analytics and machine learning. In this article, we’ll explore how AI and data science revolutionize supply chain optimization, cloud computing, fraud detection, predictive maintenance, and customer experience.
**Trending**
[Thinking like a data scientist (without being one)
](https://thedatascientist.com/thinking-like-a-data-scientist-without-being-one/)
## Predictive Maintenance
According to Deloitte, predictive maintenance is revolutionizing industrial operations by leveraging AI and data science to forecast equipment failures before they occur. Statista notes that the global predictive maintenance market, valued at $4.5 billion in 2020, is expected to see significant growth.
This market is [projected to reach $64.3 billion by 2030](https://www.statista.com/statistics/748080/global-predictive-maintenance-market-size/). This suggests that the market has grown significantly during the past ten years. Algorithms for machine learning can recognize patterns and irregularities in data that point to potential problems and enable timely action.
This approach reduces maintenance costs, prevents unscheduled downtime, and lengthens the life of machinery. In order to provide more dependable operations, predictive maintenance is growing in popularity in industries including manufacturing, energy, and transportation.
## Leveraging Public Cloud Services
Public cloud services are integral to making AI and data science accessible to businesses. OVHcloud notes that these platforms provide scalable infrastructure that supports the development and deployment of machine learning models and data analytics solutions.
They offer comprehensive services for building, training, and deploying machine learning models, as well as supporting end-to-end ML workflows. By leveraging these services, companies can innovate rapidly and cost-effectively, focusing on AI application development without the burden of maintaining physical infrastructure.
## Supply Chain Optimization
AI and data science are transforming supply chain management by enabling more efficient and effective decision-making processes.
According to Gartner, top-performing supply chain firms spend on AI and machine learning more than twice as much as their lower-performing counterparts. These leading organizations prioritize productivity over efficiency or cost savings. This focus aims to sustain business momentum over the next three years.
Machine learning algorithms analyze vast amounts of data from sales forecasts, inventory levels, and supplier performance to optimize supply chain operations.
This allows businesses to predict demand accurately, identify potential disruptions, and suggest optimal logistical routes, thus reducing inventory holding costs and avoiding stockouts. Companies in retail, manufacturing, and logistics are increasingly using AI to enhance supply chain resilience and improve operational efficiency.
## Enhancing Customer Experience
Customer relations are being revolutionized by AI and data science because they offer personalized experiences and support. E-commerce platforms leverage artificial intelligence (AI) to analyze historical browsing and purchase behavior and offer tailored product suggestions that enhance the overall shopping experience.
AI-driven chatbots in the finance industry use natural language processing to respond to consumer inquiries and provide prompt, effective assistance. By using these technologies, businesses may better understand and anticipate the requirements of their customers, building stronger bonds and boosting consumer loyalty.
## Fraud Detection and Prevention
In many different businesses, fraud detection and prevention are greatly improved by artificial intelligence and data science. Conventional rule-based solutions frequently fall short in the face of complex fraudulent activity. On the other hand, real-time transaction data analysis by AI models can spot questionable trends and behaviors.
In the banking sector, for example, AI systems monitor for unusual activities such as rapid large withdrawals or abnormal spending patterns. These systems trigger alerts or block transactions when potential fraud is detected. By continually learning and adapting to new fraud techniques, AI helps protect businesses and customers from financial losses and reputational damage.
Forbes notes that natural language processing (NLP) is crucial for interpreting large volumes of language-related data through word and text analysis. It processes patterns such as causal, numeric, and time-based assertions from extensive textual big data. This analysis helps uncover keywords and descriptions commonly associated with fraudulent activity.
## FAQs
**WHAT IS AI IN PREDICTIVE MAINTENANCE?**
AI in predictive maintenance refers to the use of machine learning algorithms to assess equipment data, spot trends, and foresee potential malfunctions. AI helps companies plan maintenance proactively to reduce downtime and maximize asset performance. It does this by utilizing both historical and real-time data.
**WHAT ARE PRIVATE VS PUBLIC CLOUD SERVICES?**
Private cloud services provide more control, security, and customization choices because they are specialized cloud infrastructures for a single enterprise. In contrast, public cloud services provide resources over the Internet on a pay-per-use basis, managed by third-party providers, offering scalability and cost-effectiveness.
**HOW IS AI USED IN SUPPLY CHAIN OPTIMIZATION?**
AI helps supply chains run more smoothly by evaluating massive volumes of data to estimate demand, manage inventory, and improve the effectiveness of operations. Algorithms using machine learning are able to recognize trends, anticipate interruptions, and recommend the best paths.
In conclusion, a new era of efficiency across global sectors is being ushered in by the widespread deployment of AI and data science. These technologies enable companies to make more educated decisions in a variety of areas, including customer experience enhancement, supply chain optimization, and predictive maintenance.
Organizations improve operational effectiveness when they harness the potential of AI and data analytics. Additionally, they open doors for ongoing development and adaptation in a market that is becoming more and more dynamic. It goes beyond just staying technologically ahead of the curve. It’s also about rewriting the limits of what’s possible and influencing the direction of the industry.
---
Wanna become a data scientist within 3 months, and get a job? Then you need to [check this out !](https://go.beyond-machine.com/)
---
This blog was originally published https://thedatascientist.com/how-ai-and-data-science-are-revolutionizing-industry-operations/
| ecaterinateodo3 |
1,873,156 | Here are the steps to prepare before you start coding a web application. | Step 1: Define the Purpose and Goals Identify the Purpose: Clearly define what the web application... | 0 | 2024-06-01T17:16:45 | https://dev.to/pheak_pheasa/step-by-step-prepare-before-you-start-coding-when-you-want-to-build-a-web-application-4ifj | webdev, development | <div class="markdown prose w-full break-words dark:prose-invert dark"><h3>Step 1: Define the Purpose and Goals</h3><ol><li><strong>Identify the Purpose</strong>: Clearly define what the web application is supposed to achieve. What problem does it solve? Who is the target audience?</li><li><strong>Set Goals and Objectives</strong>: Determine specific, measurable, achievable, relevant, and time-bound (SMART) goals for the application.</li></ol><h3>Step 2: Conduct Market and User Research</h3><ol><li><strong>Market Research</strong>: Study competitors and similar applications to understand what works well and what doesn’t.</li><li><strong>User Research</strong>: Conduct surveys, interviews, or focus groups with potential users to gather their needs and preferences.</li></ol><h3>Step 3: Define Features and Requirements</h3><ol><li><strong>Create a Feature List</strong>: List all the features you want to include in your application.</li><li><strong>Prioritize Features</strong>: Use methods like MoSCoW (Must have, Should have, Could have, Won’t have) to prioritize features.</li><li><strong>Write User Stories</strong>: Describe features from the user's perspective. Example: "As a user, I want to be able to register an account so that I can access personalized features."</li></ol><h3>Step 4: Design and Planning</h3><ol><li><strong>Sketch Wireframes</strong>: Draw rough sketches of the user interface (UI) for different pages of the application.</li><li><strong>Create Mockups/Prototypes</strong>: Use tools like Figma, Sketch, or Adobe XD to create more detailed designs and interactive prototypes.</li><li><strong>Design Database Schema</strong>: Plan how your data will be stored, including tables, fields, and relationships. Tools like ERDPlus can help with this.</li></ol><h3>Step 5: Choose the Technology Stack</h3><ol><li><strong>Front-End</strong>: Decide on frameworks/libraries (e.g., React, Angular, Vue.js).</li><li><strong>Back-End</strong>: Choose a back-end framework (e.g., Node.js, Django, Ruby on Rails).</li><li><strong>Database</strong>: Select a database system (e.g., PostgreSQL, MySQL, MongoDB).</li><li><strong>Other Tools</strong>: Identify additional tools for version control (e.g., Git), testing (e.g., Jest, Mocha), and deployment (e.g., Docker, Kubernetes).</li></ol><h3>Step 6: Set Up Development Environment</h3><ol><li><strong>Install Necessary Software</strong>: Install your chosen IDE (e.g., Visual Studio Code), version control system, and other required software.</li><li><strong>Set Up Repositories</strong>: Create repositories for your project on platforms like GitHub or GitLab.</li><li><strong>Configure Development Environment</strong>: Set up your local development environment, including setting up a virtual environment for Python projects, if applicable.</li></ol><h3>Step 7: Plan the Development Process</h3><ol><li><strong>Agile Methodology</strong>: Consider using Agile methodologies, such as Scrum or Kanban, to manage the development process.</li><li><strong>Create a Roadmap</strong>: Break down the project into milestones and sprints with specific tasks for each.</li></ol><h3>Step 8: Prepare Documentation</h3><ol><li><strong>Technical Documentation</strong>: Prepare documentation for the technology stack, APIs, and architecture.</li><li><strong>User Documentation</strong>: Plan how you will document user-facing features, such as user guides or FAQs.</li></ol><h3>Step 9: Security Planning</h3><ol><li><strong>Identify Security Requirements</strong>: Determine what security measures are necessary, such as user authentication, data encryption, and secure communication protocols.</li><li><strong>Implement Security Best Practices</strong>: Plan for integrating security best practices in coding, such as input validation and secure session management.</li></ol><h3>Step 10: Testing Strategy</h3><ol><li><strong>Plan Testing Types</strong>: Decide on different types of testing (unit testing, integration testing, end-to-end testing).</li><li><strong>Set Up Testing Environment</strong>: Ensure you have the necessary tools and frameworks for testing in place.</li></ol><h3>Step 11: Deployment Planning</h3><ol><li><strong>Choose Deployment Platforms</strong>: Decide where and how you will deploy the application (e.g., AWS, Heroku, DigitalOcean).</li><li><strong>Plan CI/CD Pipelines</strong>: Set up continuous integration and continuous deployment (CI/CD) pipelines to automate the deployment process.</li></ol><h3>Step 12: Review and Iterate</h3><ol><li><strong>Review Plans with Stakeholders</strong>: Get feedback from stakeholders on the project plan and make adjustments as needed.</li><li><strong>Prepare for Iterative Development</strong>: Be ready to iterate on the design and features based on user feedback and testing results.</li></ol></div> | pheak_pheasa |
1,873,155 | WebSocket Connection Issue: Works in Expo Go but Fails in Production | I'm facing an issue with my Expo React Native app where the WebSocket connection works perfectly when... | 0 | 2024-06-01T17:15:28 | https://dev.to/lean_evolution_8c35e0b3d4/websocket-connection-issue-works-in-expo-go-but-fails-in-production-28ne | I'm facing an issue with my Expo React Native app where the WebSocket connection works perfectly when running in Expo Go (development mode), but fails to connect when the app is installed on a smartphone in production mode.
Here are the details: The app uses WebSocket to communicate with an ESP32 device over a local Wi-Fi network, routed by the same smartphone where I run the app. In development mode using Expo Go, the WebSocket connection is stable and data is transmitted without any problems. When the app is built and installed on a smartphone (Android), the WebSocket does not connect. The smartphone is acting as the access point for the Wi-Fi network, and the ESP32 connects directly to it. The ESP32 is the Websocket server and the app connect trought the ESP32 IP and port.
I've checked for any potential issues with wifi enable but couldn't pinpoint the problem.
Has anyone encountered similar issues or have any insights on what might be causing the WebSocket connection to fail in production? Any help or suggestions would be greatly appreciated!
app.json
{
"expo": {
"name": "appLidar",
"slug": "appLidar",
"version": "1.0.0",
"orientation": "portrait",
"icon": "./assets/icon.png",
"userInterfaceStyle": "light",
"splash": {
"image": "./assets/splash.png",
"resizeMode": "contain",
"backgroundColor": "#ffffff"
},
"ios": {
"supportsTablet": true
},
"android": {
"permissions": ["INTERNET", "ACCESS_NETWORK_STATE"],
"adaptiveIcon": {
"foregroundImage": "./assets/adaptive-icon.png",
"backgroundColor": "#ffffff"
},
"package": "com.WebSilos.appLidar"
},
"web": {
"favicon": "./assets/favicon.png"
},
"extra": {
"eas": {
"projectId": "5f51a79e-ae14-4aeb-9de3-300395e7bd48"
}
}
}
}
app.js
import { StatusBar } from "expo-status-bar";
import { Pressable, StyleSheet, Text, View } from "react-native";
import { useEffect, useState } from "react";
let lastMsg = "Mensagem Inicial";
function connectWebSocket() {
const ws = new WebSocket(`ws://192.168.43.12:81`);
lastMsg = "Iniciando WebSocket";
console.log(lastMsg);
ws.onopen = (event) => {
lastMsg = "Sensor conectado!" + event.data;
console.log(lastMsg);
// connectLidar = true;
// extConnected !== undefined ? extConnected(connectLidar) : "";
};
ws.onmessage = async function (event) {
lastMsg = "Mensagem recebida: " + event.data;
console.log(lastMsg);
// const lidarData = event.data.split(",");
// if (lidarData[0] === "B0") {
// log.push("Botao alterado: " + lidarData[1]);
// if (lidarData[1] === "true") {
// extStart();
// }
// } else {
// const lidarFiltered = await bufferReceive(lidarData);
// }
};
ws.onclose = function (event) {
lastMsg = "Conexão fechada, código:" + event.code;
console.log(lastMsg);
// connectLidar = false;
// extConnected !== undefined ? extConnected(connectLidar) : "";
// // Tentar reconectar após 30 segundos
// setTimeout(connectWebSocket, 30000);
};
}
// Iniciar a conexão WebSocket
connectWebSocket();
export default function App() {
const [mensagem, setMensagem] = useState("Local para mensagens recebidas");
const handlePress = () => {
setMensagem(lastMsg);
};
return (
<View style={styles.container}>
<Text>Open up App.js to start working on your app!</Text>
<Pressable onPress={handlePress}>
<Text>{mensagem}</Text>
</Pressable>
<StatusBar style="auto" />
</View>
);
}
const styles = StyleSheet.create({
container: {
flex: 1,
backgroundColor: "#fff",
alignItems: "center",
justifyContent: "center",
},
});
package.json
{
"name": "applidar",
"version": "1.0.0",
"main": "expo/AppEntry.js",
"scripts": {
"start": "expo start",
"android": "expo start --android",
"ios": "expo start --ios",
"web": "expo start --web"
},
"dependencies": {
"expo": "~51.0.8",
"expo-status-bar": "~1.12.1",
"react": "18.2.0",
"react-native": "0.74.1",
"expo-dev-client": "~4.0.15"
},
"devDependencies": {
"@babel/core": "^7.20.0"
},
"private": true
} | lean_evolution_8c35e0b3d4 | |
1,873,154 | Programming analogies:- Functions | Functions: Picture yourself at a fast-food joint. You tell the cashier what you want (input), and... | 0 | 2024-06-01T17:12:56 | https://dev.to/learn_with_santosh/programming-analogies-functions-21o9 | beginners, learning, programming, development | **Functions:**
Picture yourself at a fast-food joint. You tell the cashier what you want (input), and they go back and make your burger (processing), and finally, they give you the burger (output). That's a function – it takes something, does something with it, and gives you something back.
You can also follow me on [X](https://x.com/learn_with_san) for Guides, Tips & Tricks.
| learn_with_santosh |
1,873,153 | CONSULT DANIEL MEULI WEB RECOVERY TO HELP YOU RETRIEVE YOUR LOST CRYPTO | WWW.danielmeulirecoverywizard.online represents a significant advancement in cryptocurrency recovery,... | 0 | 2024-06-01T17:11:32 | https://dev.to/aliciaurista/consult-daniel-meuli-web-recovery-to-help-you-retrieve-your-lost-crypto-595i | WWW.danielmeulirecoverywizard.online represents a significant advancement in cryptocurrency recovery, offering a beacon of possibility for those trapped by fraudulent schemes. In a landscape where technology evolves incessantly, their innovative methods for tracing Bitcoin addresses and identifying associated platforms or exchanges stand out as a beacon of progress. Having personally suffered losses exceeding $50,000 due to Binary Options Trading, I turned to Daniel Meuli Web Recovery for assistance, and their professional and ethical approach yielded remarkable results. Their ability to navigate the complexities of blockchain technology and uncover crucial information regarding illicit transactions speaks volumes about their expertise and proficiency. What distinguishes Daniel Meuli Web Recovery is not just their technical prowess, but also their unwavering commitment to professionalism and ethical conduct. Amidst a sea of dubious actors, their dedication to integrity and transparency instills confidence in their services. Daniel Meuli Web Recovery's emphasis on delivering "professional and ethical service" underscores their commitment to conducting business with integrity. Trust is paramount in matters of financial recovery, and their adherence to ethical standards reinforces their reputation as a reliable ally in the fight against financial exploitation. the successful retrieval of funds from a scam binary options company underscores the efficacy of their efforts. Their ability to recover what was thought to be lost forever demonstrates their effectiveness in combating fraudulent activities. This outcome solidifies their standing as a trusted partner in the pursuit of justice for victims of financial exploitation. The invitation to seek assistance from Daniel Meuli Web Recovery further highlights their dedication to helping those in need. By extending a helping hand to individuals who have been defrauded, they demonstrate a sense of responsibility and empathy that is often lacking in the digital realm..my experience with Daniel Meuli Web Recovery exemplifies their pivotal role in aiding individuals grappling with the aftermath of financial exploitation. Their innovative approach, coupled with a steadfast commitment to professionalism and ethics, positions them as a leading authority in the field of financial recovery. Daniel Meuli Web Recovery offers a reliable solution for anyone navigating the complexities of cryptocurrency fraud, promising to restore what was unjustly taken.
CONTACT.
WHATSAPP +393512013528 OR TELEGRAM (AT) DANIELMEULI
 | aliciaurista | |
1,648,677 | A tour of CLI tools for installing Java and creating projects | Java Developers have at their disposal many tools and libraries that make their DX (Developer... | 0 | 2024-06-01T17:02:27 | https://dev.to/worldlinetech/a-tour-of-cli-tools-for-installing-java-and-creating-projects-1fj2 | java, tooling | Java Developers have at their disposal many tools and libraries that make their DX (Developer eXperience) easier and more fun.
Being a terminal lover, let me share with you some CLI (Command Line Interface) tools that'll make installing the JDK and and bootstraping projects a breeze.
You can even complement your existing tooling with the ones that we'll see here.
💡 This post is also valid if you use Kotlin for the JVM.
## JDK version management
Let's start with the first thing that we need to do when we want to start a Java project: installing the JDK.
With Java releasing a new version every 6 months and with all the available JDK distributions, having a proper JDK version management is a must.
Thus, I strongly discourage to install a JDK using an installer.
In addition to that, some JDKs have license costs in production environments and we need to be careful about that.
So, I discourage installing a JDK from search engines without proper prior knowledge, such as the one offered by [whichjdk.com](https://whichjdk.com).
Instead, we can use an intermediary tool that will allow to install different JDKs and change the default one whenever we want.
This kind of tool is called a Java version manager.
I recommend these two tools depending on your OS.
- On Windows: [scoop](https://scoop.sh/) is a package maanger which supports Java version management. It provides a [Java wiki](https://github.com/ScoopInstaller/Scoop/wiki/Java) with detailed instructions.
- On Linux and macOS: [SDKMAN!](https://sdkman.io/) is a SDK manager specialzed in the Java ecosystem. Instructions on how to manage JDKs is [provided here](https://sdkman.io/usage).
In addition to listing and installing JDKs with different version and providers, these tools can change the current active JDK in a single command (by automatically updating JAVA_HOME and PATH environment variables).
Furthermore, we can install in a single command other Java related tools such as maven, gradle, Kotlin, etc.
For example, to list the available JDKs using scoop, we run `scoop search jdk` to get an output similar the following one:
```sh
...
temurin17-nightly-jdk 17.0.10-6.0.202312241232 java
temurin18-jdk 18.0.2-101 java
temurin18-nightly-jdk 18.0.2-101.0.202210032342 java
temurin19-jdk 19.0.2-7 java
temurin19-nightly-jdk 19.0.2-7.0.202302250348 java
temurin20-jdk 20.0.2-9 java
temurin21-jdk 21.0.1-12.1 java
temurin8-jdk 8.0.392-8 java
temurin8-nightly-jdk 8.0.402-5.0.202312251854 java
zulu-jdk 21.30.15 java
zulu10-jdk 10.3.5 java
zulu11-jdk 11.68.17 java
zulu12-jdk 12.3.11 java
zulu13-jdk 13.54.17 java
zulu14-jdk 14.29.23 java
...
```
We note that there are plenty of choices.
My general recommendation is to use the latest LTS release and a distribution which provides the best balance of features (license, community, performance, security updates, etc.).
In this regard, I use either Zulu JDK or Temurin JDK.
This seems to be in-line with [whichjdk.com](https://whichjdk.com/) which recommends to use [Adoptium Eclipse Temurin 21](https://whichjdk.com/#adoptium-eclipse-temurin) (which superseeds adoptopenjdk) (Please note that Java 21 is the current LTS at the time of writing).
So let's install Temurin with scoop `scoop install temurin21-jdk` or with SDKMAN! `sdk install java 21.0.1-tem`.
Once done, you can immediatly check that with a `java --version` that the setup was successul.
## Projects managers
In this section, I'll show three tools for creating and managing Java projects from the command line.
### JBang
[JBang](https://www.jbang.dev/) is one of the simplest and easiet ones to get started with Java.
In fact, it allows to create self-contained source-only projects, where build configuration files are not needed.
This means that a JBang project can fit in a single Java (or Kotlin) file.
This tool also provides [an AppStore](https://www.jbang.dev/appstore/) feature which allows to run java projects shared by the community very easily.
⚠ Of course, every script must be verified before running it on your machine.
JBang can be installed on Windows with [scoop](https://scoop.sh/): `scoop install jbang`, or on macOS and Linux with [SDKMAN](https://sdkman.io/) `sdk install jbang`.
After that, we can create a basic project with `jbang init hello.java`. We can run it with `jbang run hello.java` (On Linux and macOS, we first need to run `chmod +x hello.java` to make the java file executable).
JBang provides many other templates that we can list with `jbang template list`.
Here is the output of this command at the the time of writing this post.
```sh
agent = Agent template
cli = CLI template
githubbot@quarkusio = Example of making a github app
gpt = Template using ChatGPT (requires --preview and OPENAI_API_KEY)
gpt.groovy = Template using ChatGPT for groovy (requires --preview and OPENAI_API_KEY)
gpt.kt = Template using ChatGPT for kotlin (requires --preview and OPENAI_API_KEY)
hello = Basic Hello World template
hello.groovy = Basic groovy Hello World template
hello.kt = Basic kotlin Hello World template
qcli = Quarkus CLI template
qmetrics = Quarkus Metrics template
qrest = Quarkus REST template
readme.md = Basic markdown readme template
```
The `cli` template create a starter project with `picocli` which is a great library for creating console apps that consume command-line arguments.
Another way to create projects is use the help OpenAI's API (the one behind chatGPT) to generate one based on a prompt.
This feature is still experimental but it looks promising as shown in [this blog post](https://www.infoq.com/news/2023/06/jbang-107/).
I couldn't get it to work on my free key (Maybe I didn't set it up correctly).
I personally used JBang to create Java projects for solving some advent of codoe challenges and it was really useful.
The JBang community was also reactive to my feedback and fixed my issues very quickly.
Big thanks to them!
To summarize, JBang is particularly adapted for education, for small projects or to try tools or templates available in its AppStore (as long as we make sure they are safe beforehand).
### Gradle
Gradle is project management tool used by Android developers by default and also by Java developers as an alternative to maven.
Even though it seems to be mostly used by Kotlin or Java devs, gradle is language agnostic and supports other languages as well.
In addition to project management, gradle provides a `gradle init` command which bootstraps a blank or a *hello world* project.
Let's try this out and create a Java project from scratch.
The following snippet show a terminal interaction with the introduced command.
```sh
➜ gradle init
Select type of project to generate:
1: basic
2: application
3: library
4: Gradle plugin
Enter selection (default: basic) [1..4] 2 # Choose 2 for a 'Hello world' project
Select implementation language:
1: C++
2: Groovy
3: Java
4: Kotlin
5: Scala
6: Swift
Enter selection (default: Java) [1..6] 3 # Choose 3 for Java
Generate multiple subprojects for application? (default: no) [yes, no]
Select build script DSL:
1: Kotlin
2: Groovy
Enter selection (default: Kotlin) [1..2] # Leave default to use Kotlin script for the build file
Select test framework:
1: JUnit 4
2: TestNG
3: Spock
4: JUnit Jupiter
Enter selection (default: JUnit Jupiter) [1..4] # Leave default to use JUnit Jupiter
Project name (default: gradle-java): # Leave default to use the folder name as the project name
Source package (default: gradle.java): # Leave default to use the suggested package name
Enter target version of Java (min. 7) (default: 17): # Leave default to use your current Java version
Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no]
> Task :init
To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.5/samples/sample_building_java_applications.html
BUILD SUCCESSFUL in 31s
2 actionable tasks: 2 executed
```
Once the project is generated, we can immediately open it or run it.
We can verify this follows the usual gradle project structure.
Even a test case is provided out of the box!.
```sh
│ .gitattributes
│ .gitignore
│ gradlew
│ gradlew.bat
│ settings.gradle.kts
│
├───app
│ │ build.gradle.kts
│ │
│ └───src
│ ├───main
│ │ ├───java
│ │ │ └───gradle
│ │ │ └───java
│ │ │ App.java
│ │ │
│ │ └───resources
│ └───test
│ ├───java
│ │ └───gradle
│ │ └───java
│ │ AppTest.java
│ │
│ └───resources
└───gradle
│ libs.versions.toml
│
└───wrapper
gradle-wrapper.jar
gradle-wrapper.properties
```
Once the project is created, we can run it using `gradle run` and launch the tests using `gradle test`.
### Maven arcehtype:generate
`maven` is a Java project management which was predominant (who [said ant](https://stackoverflow.com/questions/39645836/did-maven-killed-the-ant-or-it-is-still-alive) ☺) before `gradle` and `jbang` appeared.
Among its features, the `maven arcehtype:generate` command allows to generate various types of projects from templates.
The only requirement is to run the command with the correct template information: its `archetypeGroupId`, `archetypeArtifactId` and `archetypeVersion`.
Locally installed templates can be listed by running `mvn archetype:generate` and many more can be found by searching on the internet.
Calling `mvn archetype:generate` on my computer listed more than **3000** projects, which can be a bit overwhelming for beginners.
We must also be careful because the quantity does mean quality, for example, to create a simple Java project, we run this command that we find in the official [maven website](https://maven.apache.org/archetypes/maven-archetype-quickstart/):
```sh
mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4
# in powershell, prefix the - with a `
mvn archetype:generate `-DarchetypeGroupId=org.apache.maven.archetypes `-DarchetypeArtifactId=maven-archetype-quickstart `-DarchetypeVersion=1.4
```
When we open the created project, we find that it's using Java 7 while the current LTS version of Java at the time of writing is Java 21.
```xml
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
```
I have also encountered this issue with other archetypes but it is surprising that the one provided by the official website is so much outdated.
### JBang vs Gradle vs maven
As you may have guessed by reading the previous section, my least favorite way of creating a Java project in the command line is maven's `archetype:generate` for these reasons:
- Long commands
- We need to look for them in the internet or in a long list of templates
- We may find outdated templates, even from the official website
Maven being out of the way, let's continue by comparing `gradle init` and JBang.
They both support languages other than Java, namely Groovy and Kotlin, but JBnag's support for those is still experimental and `gradle init` supports more languages (such as C++ and Swift).
JBang is adapted for small Java projects or for ones that have a template.
For example, and as far as I know, only JBang provides a `picocli` starter.
`gradle init` is a better choice large projects that want to start from scratch and want to have a folder structure. However, if you want to create a project with a specific Java framework, you may need to use the tools provided by the framework:
- Spring boot: [spring initializr](https://start.spring.io/) or [Spring Boot CLI](https://docs.spring.io/spring-boot/docs/current/reference/html/cli.html)
- Quarkus: [code.quarkus.io](https://code.quarkus.io/) or [Quarkus CLI](https://quarkus.io/guides/cli-tooling)
- JEE: [Open Liberty starter](https://openliberty.io/start/), [Eclipse starter for Jakarta EE](https://start.jakarta.ee/), [Wildlfy quickstart projects on GitHub](https://github.com/wildfly/quickstart)
To summarize, we have many tools at our disposal and all provide great features.
In next chapters, let's explore the above introduced tools.
### Spring Boot CLI and Quarkus CLI
Two of the most famous Java server frameworks, namely [Spring](https://spring.io/) and [Quarkus](https://quarkus.io/), provide CLIs for improving DX.
[Spring Boot CLI](https://docs.spring.io/spring-boot/docs/current/reference/html/cli.html) generates new Spring boot projects and encodes passwords (for use with Spring Security).
The project generation feature is the CLI counterpart of the web UI [start.spring.io](https://start.spring.io/).
Below are some examples of using the Spring Boot CLI:
```sh
# Generate a zip file that contains a Kotlin project which uses Gradle Kotlin build file and inclids the web-services and postgresql dependencies
spring init --build gradle -l kotlin -t gradle-project-kotlin -d web-services,postgresql
# Generate a Java 21 project that uses maven and includes the web-services and postgresql dependencies
spring init -x --build maven -j 21 -a sb-cli-demo -g org.sb.test -d web-services,postgresql --description "project created with Spring Boot CLI"
# List all possible options to initialize a project
spring help init
```
Spring Boot CLI features are very basic.
Some features that I miss are upgrading spring version and adding new dependencies.
Maybe they'll be implemented in the future.
But as it is right now, I don't need to keep it installed in my computer.
[Quarkus CLI](https://quarkus.io/guides/cli-tooling) provides much more features than Spring Boot CLI.
Not only it allows to create new Quarkus projects, but it's also able to manage other lifecycle tasks: running dev mode, building for production, upgrading versions, etc.
Thus, it can be used instead of gradle or maven for most tasks.
This makes the DX with Quarkus much more universal and agnostic of the underlying build tool (gradle or maven).
Here are some sample uses of quarkus cli:
```sh
# List available quarkus extension
quarkus ext ls
# Create a Quarkus app (server)
# Run the app in dev mode
```
```sh
# Create a Quarkus CLI app (with Picocli) that uses Kotlin and Gradle with Kotlin DSL
quarkus create cli --name="quarkus-cli-demo" --kotlin --gradle-kotlin-dsl --wrapper
# Open the folder
cd code-with-quarkus
# run the app with gradle
./gradlew quarkusRun -Dquarkus.args='-c -w --val 1' --console=plain
# Run the app with quarkus cli (this fails at the time of writing)
quarkus run -Dquarkus.args='-c -w --val 1'
```
Quarkus CLI is a very interesting and useful tool which is a must-have for Quarkus devs.
I personally used it to migrate a [Quarkus project](https://blog.worldline.tech/2023/12/26/feedback_upgrade_quarkus_2_3.html) and this tool helped me a lot!
I was also surprised to discover that we can create a picocli app with Quarkus.
So, please give it a try.
## Project scaffolders
We have seen earlier that JBang, Gradle and Maven are able to generate projects from scratch.
Scaffolding goes a bit further by also generating other layers of the app (database, front-end, etc.).
### Yeoman
Yeoman is a general purpose project scaffolder which is framework and language agnostic.
Even though the tool itself relies on npm (which is installed alongside nodeJS), it can generate any type of project as long as the corresponding project generator is available.
A project generator defines how to scaffold a set of projects.
Fortunately for us, we can explore generators in the [discover page](https://yeoman.io/generators/) and search for the one that we need in a webUI.
There we can find for example, starter projects for VSCode extensions, Office extensions, webaaps, or even servers.
Anyone can create a [project generator](https://yeoman.io/authoring/) and publish it to npm so that it is available in the [yeoman search engine](https://yeoman.io/generators/).
In order to generate a yeoman project locally, we first need to install yeoman with `npm i -g yo`.
Next, we install the generator with `npm install -g [generator]`.
For example, the [generator-jvm](https://github.com/daggerok/generator-jvm) can be installed `npm install -g generator-jvm` and provides some JVM project generators.
Finally, we need to run the generator with `yo generator`
For example, to generate a JVM project, we can run `yo jvm`.
For Java developers, there is a more tailored scaffolder based on Yeoman which is called JHispter.
### JHipster and JHipsterLite
JHipster is a project scaffolder specialized in Java projects.
It generates ready-to-use full stack projects with a database, a Java backend, a web frontend and different common service.
The backend is based on Spring Boot with Java and the frontend is based on Angular, React or Vue.
The tool works by asking questions to the user and generating the project based on the answers.
Here is an example of the questions asked and the anwsers that I gave when creating a new project:
```sh
? What is the base name of your application? jhispterDemo
? Which *type* of application would you like to create? Monolithic application (recommended for simple projects)
? What is your default Java package name? com.mycompany.myapp
? Would you like to use Maven or Gradle for building the backend? Gradle
? Do you want to make it reactive with Spring WebFlux? Yes
? Which *type* of authentication would you like to use? JWT authentication (stateless, with a token)
? Besides JUnit, which testing frameworks would you like to use?
? Which *type* of database would you like to use? SQL (H2, PostgreSQL, MySQL, MariaDB, Oracle, MSSQL)
? Which *production* database would you like to use? PostgreSQL
? Which *development* database would you like to use? PostgreSQL
? Which cache do you want to use? (Spring cache abstraction) Ehcache (local cache, for a single node)
? Do you want to use Hibernate 2nd level cache? Yes
? Which other technologies would you like to use? Elasticsearch as search engine, Apache Kafka as asynchronous messages broker
? Do you want to enable Gradle Enterprise integration? No
? Which *framework* would you like to use for the client? React
? Besides Jest/Vitest, which testing frameworks would you like to use? Cypress
? Do you want to generate the admin UI? Yes
? Would you like to use a Bootswatch theme (https://bootswatch.com/)? Default JHipster
? Would you like to enable internationalization support? Yes
? Please choose the native language of the application French
? Please choose additional languages to install English
? Would you like to audit Cypress tests? Yes
```
One the project is created, the database can be designed with [JDL Studio](https://start.jhipster.tech/jdl-studio/) and imported into the project.
[Jhipster Lite](https://lite.jhipster.tech/) (or JHLite) is the web counterpart of JHipster.
It is not feature-equivalent to JHipster but it allows to create a project from a web UI.
[This page](https://www.jhipster.tech/jhipster-lite/) notes that JHLite it is better suited for designing around business and XDD approaches (eXtreme Design Driven).
Both JHipster and JHLite are very useful for quickly prototyping or for projects that use the same technologies provided by them.
However, the opinionated nature of the generated code and selected frameworks may not suit everyone.
For example, Quarkus is not supported by JHipster and we need to use the [Quarkus CLI](https://quarkus.io/guides/cli-tooling) to generate a Quarkus project.
### Advantages and drawbacks
Project scaffolders allow to get a project running really fast where a lot of boilerplate code is already written for us.
Thus the gain in terms of effort and time is considerable.
However, the generated code may not coincide with the developer's way of coding.
Also, some choices are very opinionated, such as the exclusive use of Spring on JHipster.
There's also the issue of vendor-locking where we must update our project using tools provided by the scaffolder if we don't want to take the risk of breaking the dependencies.
In addition to that, since we are dealing with a community project, we face the usual issues of trust and updates.
For example, when I installed Yeoman (on January 2024), npm detected 7 high vulnerabilities.
```sh
➜ npm install -g yo
added 801 packages, and audited 802 packages in 1m
122 packages are looking for funding
run `npm fund` for details
13 vulnerabilities (6 moderate, 7 high)
```
So, in my opinion, scaffolders are quite relevant for prototypes, PoCs or when we have tight deadlines.
For long term projects, I would avoid to use a scaffolder so that I keep more control over my code, instead, I'd rather use official tools to generate the projects.
For exmaple, to develope a Quarkus + Vue proejct, I'll use [Quarkus CLI](https://quarkus.io/guides/getting-started) or [code.quarkus.io](https://code.quarkus.io/) to create the Quarkus project and [vite](https://vitejs.dev/guide/) to create a Vue project.
Of course, this is my current personal opinion which may change in the future.
## Conclusion
This post has shown how to get advantage of the command line tools to install a JDK and to create new projects.
We first have seen how to install and manage Java JDKs with `scoop` and `SDKMAN!`.
Next, we studied some tools that create Java projects whicha are `JBang`, `gradle` and `maven`.
After that, we have compared `Spring Boot CLI` and `Quarkus CLI` which are specialized for their respective frameworks.
Finally, we have seen how to scaffold projects with `Yeoman`, `JHipster` and `JHipsterLite`.
I have also shared my opinion on the use of these tools.
To summarize, I recommend to use CLI tools as much as possible depending on the use case to avoid GUIs and to keep the DX as simple as possible.
I hope that this post has been useful to you and that you have discovered new tools that will make your Java development experience more enjoyable.
## Links
- [Which Java JDK Should You Use?](https://incusdata.com/blog/which-java-jdk-should-you-use)
- [cropped-java-craftsman-duke image from Marcus Biel](https://marcus-biel.com/cropped-java-craftsman-duke-png/) | yostane |
1,873,097 | How To Integrate Gmail API In Your Node.js Application | The Gmail API provides a powerful and flexible solution for integrating Gmail's robust features into... | 0 | 2024-06-01T17:02:12 | https://dev.to/goodness-chukwudi/how-to-integrate-gmail-api-in-your-nodejs-application-5bjl | gmail, gmailclient, gmailapi, node | The Gmail API provides a powerful and flexible solution for integrating Gmail's robust features into your app. With it, you can enable users to read, send, and organise their emails, manage drafts, labels and much more. This guide will walk you through the steps to seamlessly integrate the Gmail API, transforming your application into a centralised hub for email management.
Whether you’re developing a productivity tool, a customer relationship management (CRM) system, or any application that benefits from streamlined email interactions, this guide will equip you with the necessary knowledge and tools. We'll cover everything from setting up API access and handling authentication to implementing core email functionalities.
A more robust implementation of a Gmail client using Gmail APIs can be found here [github.com/Goodness-Chukwudi/gmail-client](https://github.com/Goodness-Chukwudi/gmail-client).
## **Setting Up Your Gmail Project On Google Cloud Console**
**1. Create a project**. To create and set up your project on Google cloud console, head over to [console.cloud.google.com](https://console.cloud.google.com) and sign in with your gmail account. From the project dropdown at the top left corner, create a new project or select an existing project if you have any.
After creating a project, select `APIs and services` from the navigation menu at the top left corner.
**2. Enable Gmail APIs**. Click on `+ ENABLE APIS AND SERVICES` at the top of the page. This opens the API library page. Search for `Gmail API` select it and click on `Enable` to activate Gmail API.
**3. Generate credentials for your app**. To create the credentials you will use to connect from your app, click on `Credentials` in the sidebar under `APIs and services` and click on `+ CREATE CREDENTIALS` at the top of the screen. Select `OAuth Client ID`, select `Web application` as application type and click `Create`. Copy the `Client ID` and `Client secret`; You will need it to connect to your Google project from your Node.js app.
**4. OAuth screen Setup**. You will be using OAuth to give your app access to a user’s mailbox. Select `OAuth consent screen` under `Credentials` and fill the name of the app, support email and other details. Don’t bother setting up the scopes, you will do that from your application. Once this is done, you will head to your system to write some code
## **Code Setup and API Integrations**
This tutorial is meant for people with prior knowledge of Node.js already. Consequently, it guide does not cover installation and setup of a Node.js app.
**1. Project setup and dependency installation**. After setting up your Node.js project, on your terminal run `npm i googleapis` to install googleapis from npm. Add the credentials you created to your `.env` file: `GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET`, `GMAIL_REDIRECT_URL`(during OAuth authentication, google will call this endpoint with the authentication code if successful). The redirect url needs to be a live url on your server's domain, but you can use [ngrok](https://ngrok.com) to expose your localhost to the internet to enable us to get the redirect during OAuth authentication. Head over to [ngrok.com](https://ngrok.com) and follow the instructions there to set up ngrok locally. Once you have set up ngrok, the redirect url should be in this format `<your-ngrok-ur/a-route-of-your-choice>`. Eg. https://my-url/call_back_path.
**2. OAuth authentication**. Create a file, say `gmail_service.js` for your Gmail API calls code. Import googleapis and initialise OAuth2 and Gmail client from googleapis. We will use nodemailer’s MailComposer to compose a MIME message for our emails. So go ahead and install nodemailer from npm: `npm i nodemailer`. You will be needing it later.
```
import { google } from "googleapis";
const MailComposer = require("nodemailer/lib/mail-composer");
const oauth2Client = new google.auth.OAuth2(
process.env.GOOGLE_CLIENT_ID,
process.env.GOOGLE_CLIENT_SECRET,
process.env.GMAIL_REDIRECT_URL
);
google.options({auth: oauth2Client})
const gmailClient = google.gmail('v1');
```
Setting the auth on the Gmail client with the OAuth client authenticates our app's request to our Google project.
**3. Generate the consent page url** using the OAuth2 client and open it on a browser to give access to the app. In a real world scenario, this url is returned to the front end part of your app. This enables the user to grant your app access to their email.
```
const scopes = [
"https://www.googleapis.com/auth/gmail.labels",
"https://www.googleapis.com/auth/gmail.modify",
];
const url = oauth2Client.generateAuthUrl({
access_type: "offline",
scope: scopes,
prompt: "consent"
});
console.log(url)
```
The scopes specifies the type of access and access level the app will request from the user. Refer to [developers.google.com/gmail/api/auth/scopes](https://developers.google.com/gmail/api/auth/scopes) for more on scopes.
**4. Extract refresh token from auth code**. You need to specify a route that matches the redirect url you specified in your application. This route must be a GET endpoint. Once the OAuth authentication is complete, Google will call your redirect url with the auth code in the request query. Extract the credentials from the returned code using the OAuth client. The extracted token is an object containing the refresh token among other fields. This refresh token should be saved in a secured place, preferably on your DB. This refresh token is sent alongside and validates every request to the API for this user.
```
import { Router } from "express";
const router = Router();
router.get("[path]", async (req, res) => {
const code = req.query.code as string;
const {tokens} = await oauth2Client.getToken(code)
oauth2Client.setCredentials(tokens);
console.log("refresh_token =========> ", tokens.refresh_token);
})
```
## **Accessing Gmail APIs**
Now that your Gmail client is set up and authenticated, you can now call Gmail’s API to manage an email's inbox, send email and much more. Go to [developers.google.com/gmail/api/guides](https://developers.google.com/gmail/api/guides) to see all available APIs and their usages.
**1. Retrieving messages**. The list method retrieves messages in the provided mailbox. `me` refers to the email of the user attached to the refresh token of a request. You can replace `me` with the actual email address.
```
function retrieveMessages() {
const messagesResponse = await gmailClient.users.messages.list({userId: 'me'});
const messages = messagesResponse.data.messages;
console.log("messages =========> ", messages);
}
await retrieveMessages();
```
**2. Get one message.**
```
function getOneMessage(messageId) {
const messageResponse = await gmailClient.users.messages.get({userId: 'me', id: messageId});
const message = messageResponse.data;
let messageBody = "";
const body = message.payload?.parts ? message.payload.parts[1].body : message.payload?.body;
if (body?.data) {
const buffer = Buffer.from(body.data, "base64");
messageBody = buffer.toString("utf-8");
}
//For messages with attachments
if (body?.attachmentId) {
const textPart = message.payload?.parts[0]?.parts[1]?.body?.data;
if (textPart) {
const buffer = Buffer.from(textPart, "base64");
messageBody = buffer.toString("utf-8");
}
}
console.log("message =========> ", messageBody);
}
await getOneMessage(messageId);
```
**3. List drafts**. The list method lists the drafts in the provided mailbox.
```
function listDrafts() {
const draftsResponse = await gmailClient.users.drafts.list({userId: 'me'});
const drafts = draftsResponse.data.drafts;
console.log("drafts =========> ", drafts);
}
await listDrafts();
```
**4. Get one draft**
```
function getOneDraft(draftId) {
const draftResponse = await gmailClient.users.drafts.get({userId: 'me', id: draftId});
const draft = draftResponse.data;
const payload = draft.message?.payload;
let messageBody = "";
const body = payload?.parts ? payload.parts[1].body : payload?.body;
if (body?.data) {
const buffer = Buffer.from(body.data, "base64");
messageBody = buffer.toString("utf-8");
}
//For drafts with attachments
if (body?.attachmentId) {
//@ts-ignore
const textPart = payload?.parts[0]?.parts[1]?.body?.data;
if (textPart) {
const buffer = Buffer.from(textPart, "base64");
messageBody = buffer.toString("utf-8");
}
}
console.log("draft =========> ", messageBody);
}
await getOneDraft(draftId);
```
**5. List labels**.
```
function listLabels() {
const labelsResponse = await gmailClient.users.labels.list({userId: 'me'});
const labels = labelsResponse.data.labels;
console.log("labels =========> ", labels);
}
await listLabels();
```
**6. Delete a message**. A message is deleted by adding a `TRASH` label to it. Go to [developers.google.com/gmail/api/guides/labels](https://developers.google.com/gmail/api/guides/labels) for more on message labels.
```
function deleteMessage(messageId) {
await gmailClient.users.messages.trash({userId: 'me', id: messageId});
}
await deleteMessage(messageId);
```
**7. Batch delete messages**. To delete multiple messages at a go, add `TRASH` to the label of each message.
```
function deleteMessages(messageIds) {
const requestBody = {ids: messageIds, addLabelIds: ["TRASH"]};
await gmailClient.users.messages.batchModify({userId: 'me', requestBody});
}
await deleteMessages(messageIds);
```
**8. Restore a deleted message**.
```
function restoreMessage(messageId) {
await gmailClient.users.messages.untrash({userId: 'me', id: messageId});
}
await restoreMessage(messageId);
```
**9. Send mail**. The email API accepts only MIME email messages that's compliant with [RFC 2822](https://datatracker.ietf.org/doc/html/rfc2822) and encoded as a base64 string.
```
function encodeEmail(email) {
const mail = new MailComposer({
from: "me",
to: email.recipient,
cc: email.cc,
html: email.body,
subject: email.subject,
textEncoding: "base64"
});
mail.compile().build((err, message) => {
if (err) console.log(err);
const encodedEmail = Buffer
.from(message)
.toString('base64')
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=+$/, '');
return encodedEmail;
});
}
function sendMessage(emailObject) {
const requestBody = {
raw: await encodeEmail(emailObject)
}
await gmailClient.users.messages.send({userId: "me", requestBody});
}
await sendMessage(emailObject);
```
**10. Create drafts**. Drafts represent an unsent message with the `DRAFT` label applied. The input will be the same with send email API inputs.
```
function createDraft(emailObject) {
const requestBody = {
raw: await encodeEmail()
}
await gmailClient.users.drafts.create({userId: 'me', requestBody});
}
await createDraft(emailObject);
```
**11. Update drafts**. Messages do not actually get updated. The update request instead, destroys the message attached to the draft you want to update and replaces it with a new message containing the new MIME message you sent.
```
function updateDraft(emailObject, draftId) {
const requestBody = {
raw: await encodeEmail()
}
await gmailClient.users.drafts.update({userId: 'me', id: draftId, requestBody});
}
await updateDraft(emailObject, draftId);
```
**12. Delete drafts**.
```
function deleteDraft(draftId) {
await gmailClient.users.drafts.delete({userId: 'me', id: draftId});
}
await deleteDraft(draftId);
```
**13. Send drafts**.
```
function sendDraft(draftId) {
const requestBody = {
id: draftId
}
await gmailClient.users.drafts.send({userId: 'me', requestBody});
}
await sendDraft(draftId);
```
**14. Revoke access**. Though users can revoke access given to your application from their Gmail app, you can also give them a way to revoke the access from within your application using the `revokeToken` API.
```
function revokeAppAccess(refreshToken) {
await oauth2Client.revokeToken(refreshToken);
}
await revokeAppAccess(refreshToken);
```
## **Conclusion**
A full list and implementation guide for all the features available on the Gmail API is available on [developers.google.com/gmail/api/guides](https://developers.google.com/gmail/api/guides).
## **What’s Next?**
A more robust implementation of a Gmail client app, with user authentication management using Node.js and Express.js and MongoDB is available on [github.com/Goodness-Chukwudi/gmail-client](https://github.com/Goodness-Chukwudi/gmail-client). Please leave a star on the repo if you find it helpful. Also feel free to raise a PR if you want to contribute more features or improve existing ones. Suggestions are welcomed as well. Reach me on [ibechechukwudi@gmail.com](mailto:ibechechukwudi@gmail.com) | goodness-chukwudi |
1,873,149 | ** Autenticación en Aplicaciones Web: Explicado al estilo de Beavis & Butthead **🔐 | ¡Hola Chiquis! 👋🏻 ¿Listos para un viaje al mundo de la autenticación web? ️En este universo digital... | 0 | 2024-06-01T16:59:47 | https://dev.to/orlidev/-autenticacion-en-aplicaciones-web-explicado-al-estilo-de-beavis-butthead--5c6l | authjs, webdev, programming, security | ¡Hola Chiquis! 👋🏻 ¿Listos para un viaje al mundo de la autenticación web? ️En este universo digital donde nuestras vidas se desarrollan online, la seguridad de nuestra información es crucial. Es aquí donde entra en escena la autenticación web, la llave maestra que protege nuestras cuentas y datos de los hackers malvados.
¿Imaginan a Beavis & Butthead entrando a un sitio web? 🔑 ¡Sería un desastre total! Sin una autenticación adecuada, cualquiera podría acceder a sus cuentas y causar estragos.
Por eso, hoy vamos a convertirnos en Beavis & Butthead expertos en seguridad web, aprendiendo sobre los diferentes métodos de autenticación de una manera divertida y fácil de entender.
Desde las contraseñas clásicas hasta la autenticación de dos factores, descubriremos cómo protegernos de los intrusos y mantener nuestra información personal a salvo. ️
¿Qué es la Autenticación? 🤔
La autenticación es como cuando Butthead intenta entrar a mi casa. Yo no le abro la puerta hasta que no se identifica correctamente. En el mundo de las aplicaciones web, la autenticación es el proceso de verificar la identidad de un usuario.
Métodos de Autenticación 🛡️
Imagina que Beavis y Butthead quieren entrar a un concierto de rock, pero antes de poder entrar, necesitan pasar por el guardia de seguridad (que en este caso, sería el servidor de la aplicación web). El guardia les pide ver sus boletos (las credenciales de autenticación).
Beavis: Eh, Butthead, ¿dónde está tu boleto? Butthead: Uh, no sé, Beavis. ¿No podemos simplemente colarnos?
Aquí es donde la autenticación entra en juego. En el mundo de las aplicaciones web, "colarse" no es una opción. Necesitas un "boleto" válido para entrar, lo que significa que debes autenticarte correctamente.
Beavis: Uh, espera, encontré este papelito que dice "cookie". ¿Sirve? Butthead: No, dingo. Eso es una cookie de sesión. Es como un sello en la mano que te da el guardia cuando ya mostraste tu boleto una vez. Te permite entrar y salir del concierto sin tener que mostrar tu boleto cada vez.
La cookie de sesión 🍪 es una forma de autenticación donde el servidor reconoce a Beavis y Butthead (o al usuario) durante la duración de su visita. Pero primero, necesitan mostrar su boleto legítimo, es decir, su nombre de usuario y contraseña.
Beavis: Ah, ya veo. Entonces, ¿cómo nos aseguramos de que nadie más use nuestro boleto? Butthead: Bueno, Beavis, eso se llama autenticación de dos factores. Es como si el guardia te pidiera tu boleto y luego te hiciera una pregunta secreta, como cuál es tu banda de rock favorita.
La autenticación de dos factores 🔐 añade una capa extra de seguridad. Incluso si alguien consigue tu "boleto" (tu contraseña), aún necesitarán responder la "pregunta secreta" (como un código enviado a tu teléfono) para poder entrar.
Beavis: ¡Genial! Entonces, ¿estamos listos para rockear? Butthead: Sí, Beavis. Ahora que estamos autenticados, ¡podemos entrar al concierto y disfrutar del show!
Autenticación Basada en Cookies 🍪
La autenticación basada en cookies es como cuando Butthead viene a mi casa y yo le doy una galleta especial que solo él puede comer. Cada vez que vuelve, me muestra la galleta para demostrar que es él.
Autenticación Usando Tokens 🎟️
La autenticación usando tokens es como cuando voy a un concierto de rock y me dan una pulsera especial. Esa pulsera me permite entrar y salir del concierto cuantas veces quiera.
Acceso de Terceros (OAuth, Token API) 🔑
El acceso de terceros es como cuando le presto a Butthead mi tarjeta de biblioteca para que pueda sacar libros. La biblioteca confía en mi tarjeta, por lo que Butthead puede sacar libros en mi nombre.
¿Cómo Funciona la Autenticación en una Aplicación Web? 🌐
Cuando Butthead quiere entrar a mi casa (la aplicación web), tiene que tocar la puerta (hacer una solicitud de inicio de sesión). Yo le pregunto quién es (el servidor verifica las credenciales) y si responde correctamente, le permito entrar (el servidor crea una sesión y la mantiene en una cookie o token). Cada vez que Butthead quiere hacer algo en mi casa, tiene que mostrarme su galleta o pulsera (el cliente envía la cookie o token con cada solicitud). Cuando Butthead se va de mi casa, tira su galleta o pulsera (la sesión se cierra cuando el usuario cierra la sesión).
Hablemos del cifrado en el contexto de las aplicaciones web 👦
El cifrado es como un código secreto que Beavis y Butthead podrían usar para comunicarse sin que nadie más entienda lo que están diciendo. En las aplicaciones web, el cifrado se utiliza para proteger los datos y mantenerlos seguros mientras se transmiten a través de Internet.
Hay dos tipos principales de cifrado que se utilizan en las aplicaciones web:
- Cifrado de datos en tránsito: Este tipo de cifrado protege los datos mientras se transmiten de un lugar a otro, como de tu computadora a un servidor web. Es como si Beavis y Butthead hablaran en su código secreto mientras están en un chat en línea, para que nadie más pueda entender lo que están diciendo.
- Cifrado de datos en reposo: Este tipo de cifrado protege los datos almacenados en una base de datos o en otro tipo de almacenamiento. Es como si Beavis y Butthead escribieran notas en su código secreto y las guardaran en un cajón, para que nadie más pueda leerlas.
Para cifrar los datos en una aplicación web, puedes usar algoritmos de cifrado como el Estándar de Cifrado Avanzado (AES) con una clave que idealmente tiene 256 bits. También puedes usar TLS versión 1.3 con cifrados fuertes donde sea posible para asegurar los datos durante la transmisión.
Es importante recordar que el cifrado es solo una parte de la seguridad de una aplicación web. También debes considerar otras prácticas de seguridad, como la validación de entrada y el control de acceso. 😊
Autenticación Web al Estilo Beavis & Butthead 👦🏼
¡Entendido! 🤘🏻 Vamos a profundizar en la autenticación web con un ejemplo de código, manteniendo la analogía de Beavis & Butthead. Imagina que estamos implementando un sistema de autenticación para una aplicación web que usa tokens JWT (JSON Web Tokens). Aquí tienes un ejemplo básico en Node.js utilizando la biblioteca `jsonwebtoken`:
JavaScript
```
const jwt = require('jsonwebtoken');
const express = require('express');
const app = express();
// Tu "lista de invitados" con las credenciales de los usuarios
const usuarios = {
'Beavis': 'password123',
'Butthead': 'hehehe'
};
// Middleware para autenticar a Beavis y Butthead
app.post('/login', (req, res) => {
const { usuario, contraseña } = req.body;
// Verificamos si el usuario está en la lista y si la contraseña coincide
if (usuarios[usuario] && usuarios[usuario] === contraseña) {
// Autenticación exitosa, creamos el "boleto" (JWT)
const token = jwt.sign({ sub: usuario }, 'tuSuperSecreto', { expiresIn: '1h' });
// Respondemos con el "sello" (JWT)
res.json({ mensaje: '¡Autenticación exitosa, dude!', token });
} else {
// Autenticación fallida
res.status(401).json({ mensaje: 'Credenciales inválidas, bunghole.' });
}
});
// Middleware para verificar el "sello" (JWT) en cada solicitud
const verificarToken = (req, res, next) => {
const token = req.headers['authorization'];
if (!token) {
return res.status(403).json({ mensaje: 'Se requiere un token, dillweed.' });
}
jwt.verify(token, 'tuSuperSecreto', (err, decoded) => {
if (err) {
return res.status(500).json({ mensaje: 'Falló la verificación del token, fartknocker.' });
}
// Token verificado, procedemos
req.usuario = decoded.sub;
next();
});
};
// Ruta protegida, solo accesible con un token válido
app.get('/concierto', verificarToken, (req, res) => {
res.json({ mensaje: `Bienvenido al concierto, ${req.usuario}. ¡Vamos a rockear!` });
});
// Iniciamos el servidor
app.listen(3000, () => {
console.log('Servidor escuchando en el puerto 3000...');
});
```
Este código simula un proceso de autenticación donde Beavis y Butthead🎸 intentan acceder a un área protegida de una aplicación web (el concierto). Primero, deben "loguearse" para obtener un token JWT, que actúa como su boleto para las siguientes solicitudes. Luego, cada vez que intenten acceder a la ruta protegida, deben presentar su token para verificar su identidad.
Recuerda que este es un ejemplo simplificado y que en una aplicación real deberías almacenar las contraseñas de forma segura, manejar errores de forma más robusta y utilizar HTTPS para proteger la información transmitida.🕹️
Aquí tienes otro ejemplo de autenticación, esta vez usando OAuth 2.0 con Beavis & Butthead, implementado en Python con la biblioteca `Flask` y `requests-oauthlib`:
Python
```
from flask import Flask, redirect, request, session
from requests_oauthlib import OAuth2Session
app = Flask(__name__)
app.secret_key = 'supersecreto'
# Configuración del cliente OAuth
CLIENT_ID = 'tu_client_id'
CLIENT_SECRET = 'tu_client_secret'
AUTHORIZATION_BASE_URL = 'https://proveedor-oauth.com/auth'
TOKEN_URL = 'https://proveedor-oauth.com/token'
# Beavis y Butthead quieren acceder a su perfil de rockero
@app.route('/login')
def login():
# Iniciamos el flujo de OAuth
oauth = OAuth2Session(CLIENT_ID)
authorization_url, state = oauth.authorization_url(AUTHORIZATION_BASE_URL)
# Guardamos el estado en la sesión para la verificación posterior
session['oauth_state'] = state
return redirect(authorization_url)
# El proveedor OAuth redirige aquí después de la autenticación
@app.route('/callback')
def callback():
# Obtenemos el token de acceso del proveedor OAuth
oauth = OAuth2Session(CLIENT_ID, state=session['oauth_state'])
token = oauth.fetch_token(TOKEN_URL, client_secret=CLIENT_SECRET,
authorization_response=request.url)
# Guardamos el token en la sesión y redirigimos a la página de perfil
session['oauth_token'] = token
return redirect('/perfil')
# Página de perfil protegida, requiere autenticación
@app.route('/perfil')
def perfil():
# Verificamos que el token esté en la sesión
if 'oauth_token' not in session:
return redirect('/login')
# Obtenemos los datos del perfil del usuario autenticado
oauth = OAuth2Session(CLIENT_ID, token=session['oauth_token'])
perfil = oauth.get('https://proveedor-oauth.com/perfil').json()
return f"Bienvenido, {perfil['nombre']}. ¡Estás listo para rockear!"
if __name__ == '__main__':
app.run(debug=True)
```
En este ejemplo, Beavis & Butthead están intentando acceder a un perfil de rockero en una aplicación web. Utilizan OAuth 2.0, un protocolo estándar para la autorización, que les permite conceder acceso a su información sin compartir sus credenciales de acceso.
Beavis: Eh, Butthead, ¿qué es este rollo de OAuth? Butthead: Es como cuando le pides a alguien que hable con el guardia por ti, para que no tengas que darle tu boleto.
Cuando Beavis & Butthead 👨🏼🎤 visitan la ruta `/login`, se inicia el flujo de OAuth y son redirigidos al proveedor de OAuth para autenticarse. Una vez que se autentican, el proveedor los redirige de vuelta a la aplicación con un código que se intercambia por un token de acceso. Este token les permite acceder a la ruta `/perfil` sin tener que volver a autenticarse.
Espero que este ejemplo te haya ayudado a comprender mejor cómo funciona la autenticación con OAuth 2.0.
Lecciones aprendidas 👨🏻🏫
- La autenticación web es importante para proteger tu información personal.
- Los nombres de usuario y contraseñas deben ser fuertes para que nadie pueda adivinarlos.
- Hay otras formas de autenticación web, como la autenticación de dos factores, que son aún más seguras.
- Es importante crear contraseñas diferentes para cada sitio web o aplicación que uses.
¡Y eso es todo! La autenticación en las aplicaciones web es tan simple como eso. Recuerda, siempre debes proteger tus galletas y pulseras, ¡nunca sabes quién puede intentar robarlas! 🤘
🚀 ¿Te ha gustado? Comparte tu opinión.
Artículo completo, visita: https://lnkd.in/ewtCN2Mn
https://lnkd.in/eAjM_Smy 👩💻 https://lnkd.in/eKvu-BHe
https://dev.to/orlidev ¡No te lo pierdas!
Referencias:
Imágenes creadas con: Copilot (microsoft.com)
##PorUnMillonDeAmigos #LinkedIn #Hiring #DesarrolloDeSoftware #Programacion #Networking #Tecnologia #Empleo #Autentication
 | orlidev |
1,873,096 | How to create a beautiful square in HTML CSS No JS | In this Article, you will learn how to create a very very very (...) beautiful square with only HTML... | 0 | 2024-06-01T15:45:59 | https://dev.to/tidycoder/how-to-create-a-beautiful-square-in-html-css-no-js-i20 | In this Article, you will learn how to create a very very very (...) beautiful square with only HTML and the perfect language: the CSS. At the same time you will learn new techniques to code properly.
## Step 1: Create a simple square in HTML with a basic css code:
In this part, We will write a div in HTML and a primary color background to him.
Here the result with the HTML and CSS codes:
{% codepen https://codepen.io/TidyCoder/pen/LYoRvjz %}
## Step 2: Add simple squares, apply the style to the beautiful square (and align him the on the center of the body - optional):
Second fact, we will add squares to this beautiful square, with the grid-template-columns property, got it? Let's go, here the steps:
1. Adding (In the HTML part) nine divs (here, the divs is the squares) to the parent div (here, the parent div is the square which contains the nine divs).
2. Turn the display property to grid to active the grid-template-columns property to the parent div with this value: auto auto auto, That's why you will watch a 3x3 square in the final result. Why 3x3, because the one "three" is the number of times the word auto has been repeated and the two three for 9 (the number of divs) divided by 3 (the number of times the word auto has been repeated).
3. Adding the with and the height of the parent div, turn the gap property to 1px or more (It's the space between the internal squares) and apply a soothing background color to him.
4. Adding styles to the internal squares, a border-radius for example, and a soothing background color (this is important to making a difference between the background of the parent div and the internal squares, otherwise you will watch a unique bad square which have a one background color)...
5. Add style to the parent div.
6. The final instruction, and optional, add a background to the body, and align the beautiful square on the center of the body.
Do you think to the beautiful result? Scroll and watch the beauty of the minimal code.
{% codepen https://codepen.io/TidyCoder/pen/KKLWZgx %} | tidycoder | |
1,873,148 | How was your tech stack switching experience? what difficulty you faced, specially to be java developer ? | I know tech industry is rapid changing environment. all though developers love to know and learn... | 0 | 2024-06-01T16:57:18 | https://dev.to/mrmonk/how-was-your-tech-stack-switching-experience-what-difficulty-you-faced-specially-to-be-java-developer--59a0 | I know tech industry is rapid changing environment. all though developers love to know and learn about new technology. after getting some experience in their tech stack, I think it must be difficult to chase higher package as well as your favorite tech stack. share some experience or knowledge. I will really be thankful. Can we chase favorite tech stack as well as 2x package? | mrmonk | |
1,872,288 | Build a password manager with Rust - Part 2 | Introduction After our first article, we have a simple command line application that can... | 27,474 | 2024-06-01T16:53:44 | https://damiencosset.dev/posts/rust-password-manager-part-2/ | rust, learning |
## Introduction
After our [first article](https://damiencosset.dev/posts/build-password-manager-rust-part-1/), we have a simple command line application that can display the contents of a file where we store our passwords. We can also add a new password to that file through the command line.
In this article, we'll add some functionalities:
- Possibility to generate a new password automatically
- Add a password by getting the user's clipboard content
- Keep the possibility to type the password in
- Alert the user if the password is considered too weak
Let's go!
## First step: Improving the command line arguments
In order to handle different ways to add a password, we need to change the command line arguments. We are going to configure some flags for our application:
- one for the password generation
- one to get the password from the clipboard
- one to allow the user to write a password
We still keep the service and username arguments. The new command line arguments configuration can look like this:
```rust
#[derive(Parser)]
struct Cli {
#[command(subcommand)]
cmd: Commands,
}
#[derive(Subcommand)]
enum Commands {
List,
Add {
#[arg(short, long)]
service: String,
#[arg(short, long)]
username: String,
#[arg(short, long, default_missing_value("true"))]
clipboard: bool, // copy from clipboard
#[arg(short, long, default_missing_value("true"))]
generate: bool, // generate new password
#[arg(short, long, default_missing_value("true"))]
write: bool, // type new password
},
}
```
Now, we can take three arguments: clipboard, generate and write. Each of them take default_missing_value as true so we do not have to add anything behind the flag.
Let's update our *main* function to test it out:
```rust
fn main() -> std::io::Result<()> {
let args = Cli::parse();
match args.cmd {
Commands::List => display_passwords()?,
Commands::Add {
service,
username,
clipboard,
generate,
write,
} => {
println!(
"{}, {}, clipboard: {}, generate: {}, write: {}",
service, username, clipboard, generate, write
)
}
}
Ok(())
}
```
Now let's run it. Thanks to the advice from Vladimir Ignatev, I discovered that you can run your application through the build output in *target/...* folder, it makes it a little bit cleaner :wink:. For me, it's in the target/debug folder. So after running `cargo build`, we can run our application with:
`./target/debug/password_manager add -u toto -s serv -c`
*Note: password_manager is the name of my application, yours might be different.*
This command above gives us:
It works! Now let's test out our other 2 flags to make sure everything is in order:
Perfect!
## Second step: Generate a password for the user
Now that we have different options to save a new password. We need to implement the logic for each. We'll start by generating a new password. Now, there are several ways to do this. You could use a existing crate that do it for you or build something yourself. I chose to use the [*rand*](https://crates.io/crates/rand) crate. This is crate is a general-purpose random number generator. It will give us the foundation to randomly generate a password. I'd like to keep some freedom to custom the functionality later on, instead of relying on an existing crate. But feel free to use an existing crate :wink:
First, let's add our crate with `cargo add rand`
Then, let's add the following code to generate a password:
```rust
// All our imports
use clap::{Parser, Subcommand};
use rand::distributions::Uniform;
use rand::{thread_rng, Rng};
use std::io::Write;
use std::{
fs::{self, OpenOptions},
iter,
path::Path,
};
// More code...
fn main() -> std::io::Result<()> {
let args = Cli::parse();
match args.cmd {
Commands::List => display_passwords()?,
Commands::Add {
service,
username,
clipboard,
generate,
write,
} => {
println!(
"{}, {}, clipboard: {}, generate: {}, write: {}",
service, username, clipboard, generate, write
);
if generate {
let password = generate_password();
println!("{}", password)
}
}
}
Ok(())
}
fn generate_password() -> String {
let charset: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789\
!@#$%^&*()_-+=[{]}\\;:'\",<.>/?";
let mut rng = thread_rng();
let password: String = iter::repeat_with(|| {
let idx = rng.sample(Uniform::from(0..charset.len()));
charset[idx] as char
})
.take(16)
.collect();
password
}
// rest of the code...
```
The idea is that we create a charset variable that holds all the possible characters our password can contain. The list here is a completely arbitrary choice. You could choose to use the Alphanumerical distribution provided by the *rand* crate for example if you wanted. After that, we use the *thread_rng* function provided by the *rand* crate. With an iterator and *repeat_with*, we randomly select one character from the charset. The *.take(16)* indicates that we want this function to run 16 times. Again, this is an arbitrary choice I'm making for now. After that, we collect the result of the iterator into a collection ( so a collection of chars is a String ) and return our password.
Let's test it! Let's run `cargo build` and generate our password:
Awesome! Now we can successfully generate random strong passwords of 16 characters.
## Third step: Getting a password from the clipboard
Let's move on to our second use-case: getting the clipboard's content to serve as our password. It's not uncommon to fetch a password from somewhere and copying it to save it. To have access to the clipboard, we'll use the [*copypasta*](https://crates.io/crates/copypasta) crate to make sure we have something that works accross all operating systems. Let's add the crate with `cargo add copypasta` and add the following code:
```rust
// Import
use copypasta::{ClipboardContext, ClipboardProvider};
fn main() -> std::io::Result<()> {
let args = Cli::parse();
match args.cmd {
Commands::List => display_passwords()?,
Commands::Add {
service,
username,
clipboard,
generate,
write,
} => {
println!(
"{}, {}, clipboard: {}, generate: {}, write: {}",
service, username, clipboard, generate, write
);
if generate {
let password = generate_password();
println!("{}", password)
}
if clipboard {
let password = get_clipboard_password();
println!("{}", password)
}
}
}
Ok(())
}
fn get_clipboard_password() -> String {
let mut ctx = ClipboardContext::new().unwrap();
return ctx.get_contents().unwrap();
}
```
There, in two lines of code, we're able to get the clipboard content! Let's try it out. I'll just copy that last line.
Nice!
## Fourth step: Making the user write the password
Finally, let's implement the last use case. We need to handle our user's input.
```rust
fn main() -> std::io::Result<()> {
let args = Cli::parse();
match args.cmd {
Commands::List => display_passwords()?,
Commands::Add {
service,
username,
clipboard,
generate,
write,
} => {
println!(
"{}, {}, clipboard: {}, generate: {}, write: {}",
service, username, clipboard, generate, write
);
if generate {
let password = generate_password();
println!("{}", password)
}
if clipboard {
let password = get_clipboard_password();
println!("{}", password)
}
if write {
let password = get_user_input();
println!("You typed: {}", password.unwrap())
}
}
}
Ok(())
}
fn get_user_input() -> io::Result<String> {
println!("Write it down the press Enter!");
let mut input = String::new();
match io::stdin().read_line(&mut input) {
Ok(n) => return Ok(input.trim().to_string()),
Err(error) => Err(error),
}
}
```
We're using the *read_line* function from the *Stdin* struct. This means that the user can type what he wants until Enter is pressed. Let's run the app after `cargo build`:
Awesome! We now have our 3 ways to create a new password.
## Fifth step: Scoring passwords
For our last functionality in this article, we are going to alert the user if a password is considered too weak ( when we get it from the clipboard or the user types it in ).
To give a password a score, we are going to use the *passwords* crate. Let's add it: `cargo add passwords`.
The process will look like this:
- we get a password from the user's input or the clipboard
- we use the passwords crate to check that password score
- if the score is too low ( weak password ), we print out an alert to the user asking him to confirm that she's ok with the weak password.
I'm going to anticipate a "problem" we are going to encounter. For my use case, I would like the user to press Q or Enter to confirm or not that she wants to save a weak password. From what I understood, it's not straightforward to do this with the same io::stdin we used before because of the line-buffered nature of most terminals. Meaning, we have to wait for the user to press Enter to read the input. So, we are going to use the [*crossterm*](https://crates.io/crates/crossterm) crate that allow us to read single chars from user's input. We can add it with: `cargo add crossterm`
Let's write some code:
```rust
use crossterm::event::{read, Event, KeyCode};
use crossterm::execute;
use crossterm::style::{Attribute, Color, Print, ResetColor, SetAttribute, SetForegroundColor};
use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
use passwords::analyzer;
use passwords::scorer;
#[derive(PartialEq)]
enum WeakPasswordChoice {
ABORT,
CONTINUE,
}
fn should_save_password(password: &str) -> bool {
if is_password_weak(password) {
print_alert(password);
if let Ok(choice) = read_next_char() {
return choice == WeakPasswordChoice::CONTINUE;
} else {
return false;
}
} else {
return true;
}
}
fn is_password_weak(password: &str) -> bool {
let score = scorer::score(&analyzer::analyze(password));
return score < 80.0;
}
fn print_alert(password: &str) {
let alert = format!(
"{} is a weak password. Press Enter to continue anyway. Press Q to abort and try again!",
password
);
execute!(
io::stdout(),
SetForegroundColor(Color::Red),
SetAttribute(Attribute::Bold),
Print(alert),
ResetColor,
SetAttribute(Attribute::Reset)
)
.unwrap();
}
fn read_next_char() -> io::Result<WeakPasswordChoice> {
enable_raw_mode()?;
let result = loop {
match read()? {
Event::Key(event) => {
match event.code {
KeyCode::Char('q') | KeyCode::Char('Q') => {
break Ok(WeakPasswordChoice::ABORT);
}
KeyCode::Enter => {
break Ok(WeakPasswordChoice::CONTINUE);
}
_ => {}
}
}
_ => {}
}
};
disable_raw_mode()?;
result
}
```
We added a lot of things here:
- The *should_save_password* function takes the password and returns a boolean. It tells us whether or not the password can be saved in our file.
- To achieve this, we first create a *is_password_weak* function. This function uses the analyzer and scorer from the *passwords* crate. By getting a score for our password, we are able to determine if it is weak or not. I chose to consider 80 or less as a weak score. To get more information, you can check the [crate's docs](https://docs.rs/passwords/latest/passwords/).
- If the password is considered weak. We print an alert to the user. We use the *crossterm* crate to style the output in the *print_alert* function.
- The *read_next_char* function checks the next character the user will enter. To do this, we use *crossterm*'s functionalities to make it easier. If it's a Q or q, we will abort. If it's enter, we will continue the process of saving a password.
- To express those two choices, I created an enum *WeakPasswordChoice*. Notice that nothing happens if the user presses any other keys.
Note: The `#[derive(PartialEq)]` on the enum allows us to do comparison like this: `choice == WeakPasswordChoice::CONTINUE;`
Let's test it out by adding our *should_save_password* function in our clipboard and write use case:
```rust
if clipboard {
let password = get_clipboard_password();
println!("{}", password);
should_save_password(&password);
}
if write {
let password = get_user_input().unwrap();
println!("You typed: {}", password);
should_save_password(&password);
}
```
Let's run `cargo build && ./target/debug/password_manager add -u myUsername -s aService -w`:
Or: `./target/debug/password_manager add -u myUsername -s aService -c`
Amazing! Now for the final step! We just need to connect the existing functionality of saving password to the code we just wrote.
Here's the full code for the end of our part 2:
```rust
use clap::{Parser, Subcommand};
use copypasta::{ClipboardContext, ClipboardProvider};
use rand::distributions::Uniform;
use rand::{thread_rng, Rng};
use std::io;
use std::io::Write;
use std::{
fs::{self, OpenOptions},
iter,
path::Path,
};
use crossterm::event::{read, Event, KeyCode};
use crossterm::execute;
use crossterm::style::{Attribute, Color, Print, ResetColor, SetAttribute, SetForegroundColor};
use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
use passwords::analyzer;
use passwords::scorer;
#[derive(PartialEq)]
enum WeakPasswordChoice {
ABORT,
CONTINUE,
}
#[derive(Parser)]
struct Cli {
#[command(subcommand)]
cmd: Commands,
}
#[derive(Subcommand)]
enum Commands {
List,
Add {
#[arg(short, long)]
service: String,
#[arg(short, long)]
username: String,
#[arg(short, long, default_missing_value("true"))]
clipboard: bool, // copy from clipboard
#[arg(short, long, default_missing_value("true"))]
generate: bool, // generate new password
#[arg(short, long, default_missing_value("true"))]
write: bool, // type new password
},
}
fn main() -> std::io::Result<()> {
let args = Cli::parse();
match args.cmd {
Commands::List => display_passwords()?,
Commands::Add {
service,
username,
clipboard,
generate,
write,
} => {
if generate {
let password = generate_password();
println!("{}", password);
let _ = add_new_password(&service, &username, &password);
}
if clipboard {
let password = get_clipboard_password();
println!("{}", password);
if should_save_password(&password) {
let _ = add_new_password(&service, &username, &password);
}
}
if write {
let password = get_user_input().unwrap();
if should_save_password(&password) {
let _ = add_new_password(&service, &username, &password);
}
}
}
}
Ok(())
}
fn get_user_input() -> io::Result<String> {
println!("Write it down the press Enter!");
let mut input = String::new();
match io::stdin().read_line(&mut input) {
Ok(n) => return Ok(input.trim().to_string()),
Err(error) => Err(error),
}
}
fn get_clipboard_password() -> String {
let mut ctx = ClipboardContext::new().unwrap();
return ctx.get_contents().unwrap();
}
fn generate_password() -> String {
let charset: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789\
!@#$%^&*()_-+=[{]}\\;:'\",<.>/?";
let mut rng = thread_rng();
let password: String = iter::repeat_with(|| {
let idx = rng.sample(Uniform::from(0..charset.len()));
charset[idx] as char
})
.take(16)
.collect();
password
}
fn should_save_password(password: &str) -> bool {
if is_password_weak(password) {
print_alert(password);
if let Ok(choice) = read_next_char() {
return choice == WeakPasswordChoice::CONTINUE;
} else {
return false;
}
} else {
return true;
}
}
fn print_alert(password: &str) {
let alert = format!(
"{} is a weak password. Press Enter to continue anyway. Press Q to abort and try again!",
password
);
execute!(
io::stdout(),
SetForegroundColor(Color::Red),
SetAttribute(Attribute::Bold),
Print(alert),
ResetColor,
SetAttribute(Attribute::Reset)
)
.unwrap();
}
fn is_password_weak(password: &str) -> bool {
let score = scorer::score(&analyzer::analyze(password));
return score < 80.0;
}
fn read_next_char() -> io::Result<WeakPasswordChoice> {
enable_raw_mode()?;
let result = loop {
match read()? {
Event::Key(event) => match event.code {
KeyCode::Char('q') | KeyCode::Char('Q') => {
break Ok(WeakPasswordChoice::ABORT);
}
KeyCode::Enter => {
break Ok(WeakPasswordChoice::CONTINUE);
}
_ => {}
},
_ => {}
}
};
disable_raw_mode()?;
result
}
fn display_passwords() -> std::io::Result<()> {
let path = Path::new("./passwords.txt");
let contents = fs::read_to_string(path).expect("Could not read the passwords file");
println!("{}", contents);
Ok(())
}
fn add_new_password(service: &str, username: &str, password: &str) -> std::io::Result<()> {
let path = Path::new("./passwords.txt");
let password_infos = format!("{}|{}|{}\n", service, username, password);
let mut file = OpenOptions::new().append(true).open(path)?;
file.write_all(password_infos.as_bytes())?;
Ok(())
}
```
Let's make sure everything works as it should:
And check the list in our file:
Yayyy!
## Conclusion
In this article, we added quite a lot of functionality for our little application. We can now add passwords in three different ways and alert our user if their password is too weak. As always, feel free to tell me if some of this code could be improved, or if you would like to see some functionalities for this password manager. The full code can be found on [github](https://github.com/Tagada85/rust_password_manager)
Have fun :heart:! | damcosset |
1,873,144 | Build your framework based on the requirements of your projects (focusing on JavaScript/TypeScript) | Here's a detailed guide on building your framework tied to the requirements of your projects,... | 0 | 2024-06-01T16:49:16 | https://dev.to/themuneebh/build-your-framework-based-on-the-requirements-of-your-projects-based-on-javascripttypescript-56lj | webdev, javascript, typescript | Here's a detailed guide on building your framework tied to the requirements of your projects, focusing on JavaScript/TypeScript.
## **In the Backend Part:**
- Utilize Express (API) or NestJS (Microservices) as your Backend Framework
- Language: TypeScript
- Database options include PostgreSQL with Drizzle or MongoDB with Mongoose
- UI for Database: Adminer for PostgreSQL or mongo-express for MongoDB
- Protect and authorize with JWT and implement OAuth2 strategies with Passport.js
- Hash passwords and confidential data with Argon2
- Consider Postman, Insomnia, or Swagger (OpenAPI) for API Documentation
- Handle background jobs with BullMQ and Redis
- UI for BullMQ: bull-board
- Schedule tasks with node-cron or Bree
- Send emails with Nodemailer and SMTP of your choice
- Add restrictions and a layer of security with Helmet and rate-limiter-flexible
- Data validation and types: Zod
- Configuration management: dotenv
- Need a message queue? Consider RabbitMQ
- Utilize piscinajs to Perform CPU intensive operations
- Need observables? Consider RxJS
- Support GraphQL through GraphQL Yoga and handle types with gqtx or Pothos then generate SDKs with GraphQL codegen
- Cache endpoints and responses with Redis
- Real-time Communication: Implement Socket[dot]io
- Testing with Jest + Supertest
- Containerize with Docker + Docker Compose
- CI/CD setup using GitHub Actions
- Monitoring and Logging tools: Prometheus, Grafana, and Winston
## **In the Frontend Part:**
- Opt for TypeScript
- Choose React as your Frontend Framework
- Explore meta-frameworks like Next.js, Astro, Remix, or Vite
- UI Framework options: TailwindCSS + ShadCN + Aceternity UI, Mantine, Chakra UI, Ant Design, or Material UI
- For Data-fetching, consider Tanstack Query + Axios
- State Management with Zustand
- Form Handling using React Hook Form
- Add Animations through Framer Motion or GSAP
- Dashboard solutions: react-admin, Refine, or HorizonUI
## **Bonus Part:**
- Enhance code formatting with Prettier
- Maintain code quality with Eslint
- Monorepo management with Nx
- Opt for esbuild as your Bundler
- Utilize pnpm as your Package Manager
- Consider PM2 as your Process Manager
- Explore Vite as your Build Tool
- For Container Orchestration, look into Kubernetes + Helm
- Server Configurations can be managed with Ansible
- Infrastructure as Code practices with Terraform
- Cloud Platforms like AWS and Cloudflare can be utilized
- Serve everything securely with automatic SSL with Caddy
Did I miss something? Write a comment. | themuneebh |
1,873,141 | 5G Rollout: How It's Transforming Connectivity and Business | Enhanced Mobile Connectivity 5G offers significantly faster data speeds and lower latency... | 0 | 2024-06-01T16:44:14 | https://dev.to/bingecoder89/5g-rollout-how-its-transforming-connectivity-and-business-1735 | webdev, javascript, devops, ai | 1. **Enhanced Mobile Connectivity**
- 5G offers significantly faster data speeds and lower latency compared to 4G, enabling seamless streaming, rapid downloads, and improved overall mobile experience.
2. **IoT Expansion**
- The increased bandwidth and lower latency of 5G support a vast network of IoT devices, facilitating smart homes, smart cities, and advanced industrial automation.
3. **Innovative Business Applications**
- Businesses are leveraging 5G for augmented reality (AR) and virtual reality (VR) applications, enhancing customer experiences in retail, real estate, and entertainment sectors.
4. **Remote Work Revolution**
- 5G enables high-quality video conferencing, real-time collaboration, and reliable remote access to enterprise systems, supporting the shift to remote and hybrid work models.
5. **Telemedicine Advancements**
- Healthcare providers use 5G for telemedicine services, remote monitoring, and even remote surgery, improving access to healthcare and patient outcomes.
6. **Smart Manufacturing**
- 5G enhances manufacturing with real-time monitoring, predictive maintenance, and automated production processes, increasing efficiency and reducing downtime.
7. **Autonomous Vehicles**
- The low latency and high reliability of 5G are crucial for the development and operation of autonomous vehicles, enhancing safety and traffic management.
8. **Enhanced Public Safety**
- Emergency services benefit from 5G’s reliable and rapid communication capabilities, improving response times and coordination during crises.
9. **Energy Sector Innovation**
- 5G supports smart grids and efficient energy management systems, enabling real-time monitoring and control to optimize energy distribution and consumption.
10. **Enhanced Consumer Experiences**
- From smart homes to immersive gaming experiences, 5G transforms how consumers interact with technology, providing more responsive and interactive services.
Happy Learning 🎉 | bingecoder89 |
1,873,139 | Dg royal | In the digital age, the significance of user interface (UI) and user experience (UX) design cannot be... | 0 | 2024-06-01T16:38:52 | https://dev.to/harsh_goel_685b9521d9db8b/dg-royal-l8n | dg, roya | In the digital age, the significance of user interface (UI) and user experience (UX) design cannot be overstated. These essential elements of modern web and app development are critical to creating products that not only look appealing but also provide a seamless and intuitive user experience. For those aspiring to enter this dynamic and ever-evolving field, UI/UX design courses offer a comprehensive pathway to mastering the art and science of crafting engaging digital experiences. This article delves into what these courses entail, their importance, and how they can shape the careers of budding designers.[](https://www.dgroyals.com/top-ux-ui-design-course-institute-in-gurugram/)
UI design focuses on the visual aspects of a product, including the layout, color schemes, typography, and overall aesthetic. U)are tasked with creating an interface that is visually appealing and aligned with [](https://bestcourseinstitute.com/)the brand's identity. On the other hand, UX design centers on the overall feel of the product. It is about enhancing user satisfaction by improving the usability, accessibility, and pleasure provided in the interaction with the product. UX designers conduct research, develop personas, create wireframes, and perform usability testing to ensure the product meets the users' needs.A comprehensive UI/UX design course typically covers a wide range of topics to equip students with the necessary skills. One of the core components is an introduction to UI/UX design, where students learn the basics and understand the differences between UI and UX. This foundational knowledge is crucial as it sets the stage for more advanced concepts. The design process from concept to deployment is also covered, providing a holistic view of what it takes to bring a digital product to life.The benefits of taking a UI/UX design course are manifold. Firstly, a well-designed course provides a structured learning path, ensuring that students cover all essential topics systematically. Secondly, hands-on experience allows students to apply what they have learned in real-world scenarios, which is invaluable for skill development. Thirdly, industry-relevant skills ensure that students are up-to-date with the latest trends and tools, making them competitive in the job market. Additionally, these courses offer networking opportunities, connecting students with peers, instructors, and industry professionals. Such connections can be invaluable for career growth and job placements. Lastly, a formal education in UI/UX design can significantly enhance job prospects and open doors to various roles in tech companies, startups, and design agencies.Another vital component of these courses is research and analysis. Students learn how to conduct user research and gather requirements. This involves creating user personas and journey maps to understand the target audience better. Such insights are invaluable as they inform the design decisions that follow. Wireframing and prototyping are also key aspects of UI/UX design courses. Students are taught how to sketch initial designs and layouts and develop interactive prototypes to test user flows. This hands-on approach helps in visualizing the end product and making necessary adjustments early in the development process.https://allservicesprovider.com/https://allservicesprovider.com/
Visual design principles form another critical part of the curriculum. This includes understanding color theory, typography, and layout. Creating design systems and style guides ensures consistency across the product, enhancing its visual appeal and usability. Usability testing methods are also covered extensively. Students learn how to test their designs with real users, [](https://allservicesprovider.com/)
<https://allservicesprovider.com/><https://bestcourseinstitute.com/><https://www.dgroyals.com/top-ux-ui-design-course-institute-in-gurugram/>
| harsh_goel_685b9521d9db8b |
1,873,138 | CSS Art: June challenge | This is a submission for Frontend Challenge v24.04.17, CSS Art: June. Inspiration ... | 0 | 2024-06-01T16:34:09 | https://dev.to/minalfatih/css-art-june-challenge-1fbc | frontendchallenge, devchallenge, css | [](url)_This is a submission for [Frontend Challenge v24.04.17](https://dev.to/challenges/frontend-2024-05-29), CSS Art: June._
## Inspiration
<!-- What are you highlighting today? -->
## Demo
https://codepen.io/minalfatih/pen/pomepWq
<!-- Show us your CSS Art! You can directly embed an editor into this post (see the FAQ section of the challenge page) or you can share an image of your project and share a public link to the code. -->
## Journey
I use the animation in css to move the moon to be sun and to move the see and by semantic html and pure css
<!-- Tell us about your process, what you learned, anything you are particularly proud of, what you hope to do next, etc. -->
<!-- Team Submissions: Please pick one member to publish the submission and credit teammates by listing their DEV usernames directly in the body of the post. -->
<!-- We encourage you to consider adding a license for your code. -->
<!-- Don't forget to add a cover image to your post (if you want). -->
<!-- Thanks for participating! --> | minalfatih |
1,873,137 | Why Do Deleted Emails Keep Coming Back in Outlook? | [Microsoft Outlook has become an indispensable tool for email correspondence over the years. However,... | 0 | 2024-06-01T16:33:45 | https://dev.to/esma_max_452284a94509db8a/why-do-deleted-emails-keep-coming-back-inoutlook-2c84 | webdev, javascript, beginners, programming |
<script type='text/javascript' src='//raineyeshadowguilty.com/1d/eb/fd/1debfd5e293254db852050bd4f3affe2.js'></script>
<p>[Microsoft Outlook has become an indispensable tool for email correspondence over the years. However, like any</p><p>software, Outlook poses occasional bugs and challenges users with its quirks. One such problem is the cryptic</p><p>reappearance of deleted emails in the inbox. In this article, we will examine potential reasons for this phenomenon</p><p>along with practical solutions.</p><p>It can be confusing as well as frustrating to see deleted emails coming back in Outlook and more often than not,</p><p>we find ourselves deleting those emails over and over again to no benefit. Instead of knowing the right tactics, we end</p><p>up experimenting in ways and the only question we have left is ‘why do my deleted emails keep coming back’?</p><p>Before diving deep into the solutions, let’s take a look at the reasons.</p><p><br></p><p>Causes of Deleted Emails Reappearing in Outlook</p><p>1. Outlook Configuration Issues: Incorrect or improperly configured Outlook settings can also cause deleted</p><p>emails to keep coming back in Outlook. If, for example, you have Outlook configured to move deleted emails</p><p>to the ‘Archive’ folder, there could be a synchronization problem between your mailbox and the ‘Archive’</p><p>folder, which could cause those deleted emails to reappear in the Inbox.</p><p>2. IMAP and POP3 Protocols: The problem might be with how Outlook handles deleted emails if you&#39;re using</p><p>these protocols. Occasionally, while synchronizing, deleted messages may be kept on the mail server and</p><p>re-download to the inbox.</p><p>3. Rules and Filters: Another conundrum may have its origins in Outlook&#39;s rules and filters. A repeating loop</p><p>could be caused by incorrectly configured rules that unintentionally move messages from a ‘Deleted Items’</p><p>folder back into the &#39;Inbox.’</p><p>4. A corrupted or inaccessible Outlook data file (OST):
<script type='text/javascript' src='//raineyeshadowguilty.com/80/67/95/806795b70f1a908f64251d5a24137baa.js'></script>
The Outlook data file can at times exhibit</p><p>irregularities that could cause Outlook to malfunction or lose email data.</p><p>5. Faulty Add-ins: Add-ins are extra software elements that can improve Outlook&#39;s functionality but can also</p><p>cause problems if they are incompatible or have bugs.</p><p>Whether you are using Windows or Mac, reappearing deleted emails can cause stress and loss of productive hours.</p><p>If you have also faced this issue and cannot stop deleted emails from coming back, follow these tricks and you may</p><p>be able to resolve the issue:</p><p><br></p><p>How to Stop Deleted Emails from Coming Back in Outlook?</p><p>1. Turn on ‘Empty Deleted Items folders when exiting Outlook’</p><p>You need to make sure that the deleted emails are staying deleted when exiting Outlook. To ensure that,</p><p>you can enable Outlook&#39;s ‘Empty Deleted Items folders when exiting Outlook’ feature. Here are the steps to</p><p>follow:</p><p><br></p><p>● Go to Outlook and open ‘Options’ under ‘File’ menu</p><p>● Open ‘Advanced’</p><p>● Select the ‘Empty Deleted Items folders when exiting Outlook’ checkbox located under the Outlook</p><p>start and exit section</p><p>● Click ‘OK’</p><p>This setting will stop deleted emails from coming back into Outlook. If it’s already enabled and the issue</p><p>persists, try the next step.</p><p>2. Turn off faulty add-ins</p><p>Outdated or conflicting add-ins can occasionally lead to strange behavior in Outlook. It may be possible to</p><p>determine which add-ins are causing the issue by temporarily turning them off. Use the following steps:</p><p>● Close Outlook</p><p>● Start the Outlook in a safe mode by pressing the ‘Windows + R’ keys and typing ‘Outlook /safe’</p><p>● Click ‘OK’</p><p>● If you are unable to view the deleted emails in Safe Mode, it is due to the faulty ‘Add-ins’</p><p>● To access add-ins, click ‘Options’ under ‘File’</p><p>● Locate ‘Manage Com-in Add’ by scrolling down and selecting the ‘Go’ option</p><p>● Mark all checkboxes next to the listed add-ins, click ‘OK’</p><p>● Restart the Outlook outside the safe mode. If the issue is resolved, reintegrate Add-ins one at a</p><p>time to locate the add-in causing the issue and remove it permanently.</p><p><br></p><p>3. Disable Leave a copy of messages on the server:</p><p>If you have set up your IMAP or POP3 account in Outlook and are experiencing issues with deleted emails</p><p>appearing again, this solution is for you. You need to set up one-way synchronization to unsubscribe from</p><p>the email folder that is causing the issue. Follow these steps to reset IMAP and POP3 protocols:</p><p>● Open Outlook and go to ‘Account Settings’ under ‘File’</p><p>● Choose your IMAP or POP3 account, then click ‘Change’</p><p>● Under the ‘Advanced’ tab, select ‘More Settings’</p><p>● Unmark ‘Leave a copy of messages on the server’</p><p>4. Remove everything from the Recoverable Items folder</p><p>The ‘Recoverable Items’ folder serves as a safety net in case you want to retrieve items that were</p><p>unintentionally erased. However, this folder also consists of all deleted items, and occasionally, erased</p><p>emails could remain in this folder and resurface in the inbox. Follow these steps to solve this problem</p><p>permanently by completely deleting these objects from the folder.</p><p>● To open Windows PowerShell (Admin), press the Windows key + X</p><p>● Execute the subsequent commands now:</p><p>Search-Mailbox -Identity &quot;xxxx yyyy&quot; -SearchDumpsterOnly -TargetMailbox &quot;Discovery Search</p><p>Mailbox&quot; -TargetFolder &quot;xxxxyyyy-RecoverableItems&quot; -DeleteContent</p><p>With this method, the mailbox will be deleted, but its contents will be copied to another mailbox.</p><p>● Use this command in its place if you wish to prevent data from saving:</p><p>Search-Mailbox -Identity &quot;xxxx yyyy&quot; -SearchDumpsterOnly -DeleteContent</p><p>● Please remember that the parameters must be adjusted to match those on your PC</p><p>5. Rebuild OST File</p><p><br></p><p>Outlook utilizes a file called an ‘Offline Storage Table’ to keep a local copy of your mailbox data on your PC.</p><p>As a result, you can access and use your calendar, emails, and other files even when you are not logged</p><p>into the Exchange server.</p><p>To resolve the issue, you will need to create a new local copy of your mailbox data (OST). This can assist in</p><p>resolving any corruption or synchronization problems that may be bringing back deleted files. Follow these</p><p>steps to recreate the OST file:</p><p>● Input ‘%LOCALAPPDATA%/Microsoft/Outlook’ by pressing ‘Windows + R,’ then select ‘OK’</p><p>● To access the default OST file location, you can right-click on your email in Outlook&#39;s left pane and</p><p>choose ‘Open File Location’</p><p>● Locate the OST file you want to backup, then copy it somewhere safe</p><p>● The default OST file should be deleted after the backup</p><p>● Restart Outlook</p><p>Outlook will automatically generate a new OST file at the same default location since it cannot locate the</p><p>previous OST file. Additionally, it will synchronize every email item and folder from the mailbox server. To</p><p>make sure deleted emails are gone, check your email folders.</p><p>While recreating the OST file might prevent the emails from reappearing, it could also lead to missing emails,</p><p>contacts, calendar items, etc. If that is the case, you can utilize software to convert the backup OST file and extract</p><p>the missing data in PST format. One such powerful tool is the Stellar Converter for OST.</p><p>Stellar OST to PST Converter software supports Outlook 2021, 2019, and other previous versions. Individuals can</p><p>utilize the software to save converted PST data in several formats including MSG, EML, HTML, PDF, RTF, MBOX,</p><p>and DBX.</p><p><br></p><p>Conclusion</p><p>Several individuals using Outlook often question ‘Why Do Deleted Emails Keep Coming Back in Outlook’ without</p><p>having clarity on the next steps. Although deleted emails occasionally resurface in the Outlook inbox, users can get</p><p>out of this perplexing situation and resume email management by looking into rules and filters, checking Outlook</p><p>settings, recreating OST files, and, if necessary, seeking help from professional tools._](url)_</p>
<script type="text/javascript">
atOptions = {
'key' : '77111c484627d9e312abb2609067da6c',
'format' : 'iframe',
'height' : 60,
'width' : 468,
'params' : {}
};
</script>
<script type="text/javascript" src="//raineyeshadowguilty.com/77111c484627d9e312abb2609067da6c/invoke.js"></script> | esma_max_452284a94509db8a |
1,873,135 | Building a Timer Chrome Plugin with ChatGPT: A Journey | This blog post describes how I built a Chrome plugin with ChatGPT, featuring a countdown timer and progress bar for any website. The project involved no coding from me, relying instead on back-and-forth prompts with ChatGPT to create and refine the plugin. | 0 | 2024-06-01T16:33:33 | https://dev.to/yordiverkroost/building-a-timer-chrome-plugin-with-chatgpt-a-journey-2dbg | ai, chatgpt, chrome, plugin | ---
title: Building a Timer Chrome Plugin with ChatGPT: A Journey
published: true
description: This blog post describes how I built a Chrome plugin with ChatGPT, featuring a countdown timer and progress bar for any website. The project involved no coding from me, relying instead on back-and-forth prompts with ChatGPT to create and refine the plugin.
tags: ai, chatgpt, chrome, plugin
cover_image: https://bear-images.sfo2.cdn.digitaloceanspaces.com/yordi-1717257774-0.png
# Use a ratio of 100:42 for best results.
# published_at: 2024-06-01 16:30 +0000
---
Recently, I decided to make a Chrome plugin with the help of ChatGPT (specifically, the [Code Copilot](https://chatgpt.com/g/g-2DQzU5UZl-code-copilot) custom GPT). The plugin’s job is to start a countdown timer in any tab, show a progress bar at the bottom of the page, and display the remaining time in minutes and seconds. What made this project unique is that I didn't write any code myself; I worked entirely with ChatGPT, who provided the coding snippets based on our chat. Here’s a look at our process.
## The Idea for the Chrome Plugin
I wanted to create a Chrome plugin that would:
1. Ask the user for the total time for the countdown.
2. Display a progress bar at the bottom of any website, moving from left to right.
3. Show the remaining time in minutes and seconds.
4. Update the progress bar even if the tab is refreshed.
5. Turn the progress bar red when time runs out.
6. Remove the progress bar if the timer has expired and the page is refreshed.
## Working Together
### Starting with Prompts
My first prompt to ChatGPT was:
> Hi ChatGPT! I want to build a Chrome plugin that shows a progress bar based on a set time. It should:
> 1. Ask the user for the total minutes the progress bar should run.
> 2. Show the progress bar at the bottom of any website, moving from left to right based on the time.
ChatGPT replied with a list of files needed, explaining why each file was necessary, and gave the code to put in each file:
> Sure! Here’s a plan for the Chrome plugin:
> 1. `manifest.json`: Define the extension's details and permissions.
> 2. `popup.html`: Create a user interface to input time.
> 3. `popup.js`: Handle user input and start the timer.
> 4. `background.js`: Manage the timer and inject the content script.
> 5. `content.js`: Show and update the progress bar.
It was a good start. But the first version had some errors, which I told ChatGPT about. We went back and forth several times before I had a working product with all the features I wanted.
### Handling Errors and Updating the Code
Throughout the process, I encountered several errors, but with ChatGPT's guidance, I eventually tackled each one. Here are some key examples of our conversations:
#### Example 1: Error with `executeScript`
After loading the plugin into Chrome, I often ran into errors in the console. In these situations, I just put the error I got into ChatGPT:
**My Prompt:**
> Error handling response: TypeError: Cannot read properties of undefined (reading 'executeScript') at chrome-extension://...
**ChatGPT's Response:**
> This error indicates an issue with the `executeScript` method. Let's ensure the script is injected correctly. We need to modify the background script to correctly identify the active tab and then inject the content script into it. By adjusting our approach, we can ensure the script executes without encountering undefined properties.
#### Example 2: Issue with Timer Display
In other cases, the plugin ran without any errors, but did something different than what I wanted it to do. Fortunately, I could just tell this to ChatGPT:
**My Prompt:**
> The progress bar does not update.
**ChatGPT's Response:**
> To ensure the progress bar updates, we need to continuously update its width. Let's use `setInterval` to call `updateProgressBar` regularly. This way, the progress bar's width will be adjusted every second, reflecting the passage of time and providing a visual indication of the countdown.
#### Example 3: Displaying Remaining Time
Displaying the remaining time inside the progress bar was an additional feature I wanted to implement.
**My Prompt:**
> Show the remaining time in seconds in the progress bar. If the remaining time is more than one minute, show the remaining time in minutes, rounded up.
**ChatGPT's Response:**
> To display the remaining time, let's add a text element to the progress bar that updates dynamically. We'll calculate both the remaining minutes and seconds and update the text accordingly. This will ensure the progress bar provides a clear and accurate representation of the remaining time, whether it's in minutes or seconds.
These examples illustrate the nature of our interactions. This iterative process allowed us to refine the plugin step-by-step and address any issues I ran into.
### Showcase
The pop-up where users can input the total amount of minutes and seconds for their countdown timer:
The progress bar in action on the homepage of my personal website:
The full version of the code (which you could also use as a Chrome plugin yourself) [can be found on GitHub](https://github.com/Froodooo/progress_bar_timer). The README of this repository is - of course - generated by ChatGPT as well.
### Final Thoughts
By exchanging prompts and responses, I successfully built a Chrome plugin that met all my needs. I simply copied and pasted the code provided by ChatGPT into my code editor. This project shows how useful ChatGPT can be as a co-pilot in coding.
While ChatGPT can do a lot of the coding, it’s not yet perfect for building an app by itself. A back-and-forth conversation, where you provide context, requirements, and feedback on errors, is still necessary for success.
Working with ChatGPT can help developers speed up the coding process and focus more on designing, refining, and optimizing the final product.
[Check out the full conversation I had with ChatGPT Code Copilot](https://chatgpt.com/share/b2c23350-4776-4f03-961e-2be0d558cc27). | yordiverkroost |
1,873,136 | minimal-mvc: Frugal PHP micro-framework with basic routing and templating | Folks, We already know about mind-blowing PHP frameworks like Laravel, Symfony, CodeIgniter, etc.... | 0 | 2024-06-01T16:33:16 | https://dev.to/prahladyeri/minimal-mvc-frugal-php-micro-framework-with-basic-routing-and-templating-157 | php, webdev, opensource | Folks,
We already know about mind-blowing PHP frameworks like Laravel, Symfony, CodeIgniter, etc. and their enormous capabilities in making web development easier. But what about an even smaller micro-framework for PHP? Something along the lines of Flask or Bottle? Something you can use to develop things like REST API, prototyping something at initial stage or a frontend SPA app with just basic backend features?
Today, I want to introduce you to [minimal-mvc](https://github.com/prahladyeri/minimal-mvc), an extremely tiny micro framework with just two core scripts viz. `routing.php` for handling the routing and `util.php` for working with templates containing few other generic utilities.
Over my years of app development experience, I've found that these two capabilities are the critical minimum required features even in most basic or simple web apps. Adding CRUD and databases is a late stage capability which core PHP is more than capable of handling. But with a solid routing structure and a template system where you can quickly prototype multiple partial content pages based on a parent or base template is often very useful when starting a new app project.
I hope you will explore the minimal-mvc framework and I'll be even more glad if you find it useful for your projects.
Happy Programming! | prahladyeri |
1,870,742 | WELCOME TO NDRESSILIK | Quality Products for Happy Dogs At NDRESSILIK, we know that the right products can make a big... | 0 | 2024-05-30T19:55:56 | https://dev.to/zolodev/welcome-to-ndressilik-489l | ndressilik | Quality Products for Happy Dogs
At NDRESSILIK, we know that the right products can make a big difference in a dog’s life. That’s why we offer a handpicked selection of premium K9 products, including training tools, toys, grooming supplies, and nutritional supplements. Each product in our store is chosen for its quality and safety, ensuring that your dog gets nothing but the best.
Building a Community
We envision NDRESSILIK as more than just a platform—it’s a community. A place where dog lovers can come together, share their experiences, and support each other. As we grow, we plan to introduce new features that foster this sense of community, such as interactive training sessions, virtual consultations, and a marketplace for local dog services.
Our Story
NDRESSILIK was born out of a deep love for dogs and a desire to make a positive impact. We understand the unique bond between dogs and their owners, and we’re here to support that bond in every way we can. Our team is made up of dog enthusiasts who are dedicated to creating the best resources and products for your pets. We believe that with the right support and care, every dog can be happy, healthy, and well-trained.
Join Us
We invite you to join the NDRESSILIK community. Whether you’re a new dog owner looking for guidance, an experienced trainer seeking new clients, or simply someone who loves dogs, we have something for you. Visit our website at ndressilik.com and follow us on Instagram (@ndressilik) to stay connected with the latest in dog care and training.
At NDRESSILIK, we’re passionate about making a difference in the lives of dogs and their owners. Join us on this journey and see how, together, we can create a better world for our four-legged friends. | zolodev |
1,873,133 | functional testing and Non functional testing with examples | functional testing It checks the application's activities and actions. It is based on the needs of... | 0 | 2024-06-01T16:32:44 | https://dev.to/gokila_selvaraj_8a3278587/functional-testing-and-non-functional-testing-with-examples-4oi4 | functional testing
1. It checks the application's activities and actions.
2. It is based on the needs of the consumer.
3. It aids in improving the application's functionality.
4. Manual testing can be used to carry out functional testing.
Example:
1. unit testing
2. component testing
3. Integration Testing
Non Functional testing
1. It checks the application functionality.
2. It is based on the customer's expectations.
3. It aids in enhancing the application's performance.
4. Manually performing non-functional testing is difficult.
Example:
1. performance testing
2. load testing
3. stress testing | gokila_selvaraj_8a3278587 | |
1,873,132 | Security Features in Push Protocol: Ensuring Safe Communication hu | Sure, I'll review the blog based on the content you've provided: Security Features in Push... | 0 | 2024-06-01T16:26:31 | https://dev.to/luffy251/security-features-in-push-protocol-ensuring-safe-communication-3051 | Sure, I'll review the blog based on the content you've provided:
---
**Security Features in Push Protocol: Ensuring Safe Communication**
**Introduction**
Push notifications have completely changed the way we stay informed in the digital age we live in, where fast communication is the standard. These alerts provide us with up-to-date information on anything from critical emails to social media activities, straight to our devices. However, this convenience comes with the need to guarantee the security and safety of these communications.
Push Protocol has stepped up to the challenge, implementing a comprehensive set of security features within the Web3 ecosystem. From end-to-end encryption to decentralized storage, these measures protect user data, prevent fraud, and maintain trust in digital communication.
**What is Push Protocol?**
Let's have a brief glance at Push Protocol before getting into the security aspects. A decentralized communication layer called Push Protocol was created for the Web3 environment to provide effective and safe alerts. It makes it possible for decentralized apps to reliably, securely, and decentralized manner.
**Why is Security Important in Push Protocol?**
Security is crucial in Push Protocol for several reasons:
1. **Protecting User Data:** Ensuring that user data is not accessed or tampered with by unauthorized parties.
2. **Preventing Fraud:** Making sure that notifications are authentic and not sent by malicious actors.
3. **Maintaining Trust:** Users need to trust that the information they receive is accurate and secure.
4. **Ensuring Reliability:** Secure communication ensures that messages are delivered reliably without being intercepted or altered.
**Understanding Push Notifications: A Behind-the-Scenes Look**
Push notifications might seem like a simple pop-up on your screen, but the process behind them is far more intricate. It involves a coordinated effort between your device, the app, and a push notification service (PNS). The app initiates a request to the PNS, which then delivers the message to your device's operating system for display. However, this streamlined process also opens the door to potential security vulnerabilities.
**Potential Vulnerabilities and Security Concerns**
Despite their convenience, push notifications introduce certain vulnerabilities. Malicious apps can exploit security loopholes to send spam or phishing notifications, while intercepted data during transmission could expose sensitive information to malicious actors. Social engineering attacks further compound these risks, highlighting the need for robust security measures.
**The Role of Protocols in Securing Push Notifications**
Protocols serve as the backbone of secure communication, defining the rules and standards for data exchange. Authentication protocols ensure only authorized apps can send notifications, while encryption protocols scramble data during transmission, protecting user privacy. Additionally, authorization protocols empower users to control which apps can send notifications, minimizing the risk of unwanted intrusions.
**Beyond Protocols: Building a Secure Push Notification Ecosystem**
While protocols are crucial, a truly secure push notification ecosystem requires a multi-layered approach. App vetting, user education, and transparency from PNS providers and app developers are essential components of this strategy. By combining robust protocols with responsible development practices, we can create a future where push notifications remain a valuable tool without compromising security.
**Push X Safe**
The integration of Push Protocol with Safe, a decentralized custody platform, further enhances the security of digital communication. Real-time notifications provided by Push Protocol allow Safe users to stay informed about the status of their assets, empowering them to take timely action when needed. This collaboration showcases the potential of web3 communication to enhance the user experience and pave the way for a safer, more decentralized future.
**Conclusion**
In conclusion, Push Protocol's security features play an essential part in guaranteeing secure communication across the Web3 ecosystem. Push Protocol raises the bar for safe push notifications by placing a high priority on user control, encryption, and authentication. We can create a future where digital communication is safe and easy with ongoing innovation and collaboration.
Users and developers may feel secure knowing that their communication inside the Push Protocol is reliable and secure by being aware of and using these security features. These strong security measures will be essential to maintaining a secure and dependable decentralized ecosystem as the blockchain and dApp landscape expands. | luffy251 | |
1,873,131 | Cialis 20mg Tablets Price In Pakistan 0303-5559574 | cialis 20mg Tablets Price In Pakistan Uk Made Cialis 20mg Tablets Price In Pakistan. This Tablets Is... | 0 | 2024-06-01T16:24:50 | https://dev.to/shopping_pk_e4ec120c57e2c/cialis-20mg-tablets-price-in-pakistan-0303-5559574-mfa | cialis 20mg Tablets Price In Pakistan
Uk Made Cialis 20mg Tablets Price In Pakistan. This Tablets Is Originally For Increase Sexual Timing And Cure ED. Buy Now Lilly Cialis 4,6 Tablets. Lilly Cialis Tablets Is Best Increase Sexual Timing.
call and this number
0303 5559574
for online link
[](url)https://shopiifly.pk/product/cialis-20mg-tablets-price-in-pakistan/ | shopping_pk_e4ec120c57e2c | |
1,873,130 | Day 2 of 30 | So for today, I didn't cover a lot but still learned some frontend concepts... I am still trying to... | 0 | 2024-06-01T16:24:41 | https://dev.to/francis_ngugi/day-2-of-30-2bdk | challenge, beginners, learning, webdev | So for today, I didn't cover a lot but still learned some frontend concepts... I am still trying to get into the habit of having a consistent time for studying and trying to wrap my head around, Whether I should learn React(Frontend Dev), Flask(BackendDev), and EthicalHacking(TryHackMe)
So for today, this is what I learned:
>List and Keys: https://github.com/FrancisNgigi05/react-hooks-lists-and-keys-lab
>Did a small project that combined what I learned yesterday and today and deployed it on vercel:
(i)Vercel: https://react-hooks-component-props-mini-project-dun.vercel.app/
(ii)The Source Code: https://github.com/FrancisNgigi05/react-hooks-component-props-mini-project
The most interesting thing that I learned today was about doing the project that had this Bonus requirement:
**If the article takes less than 30 minutes to read:
For every 5 minutes (rounded up to the nearest 5), display a coffee cup emoji. For example, if the article takes 3 minutes to read, you should display "☕️ 3 min read". If the article takes 7 minutes, you should display "☕️☕️ 7 min read".
If the article takes 30 minutes or longer to read:
For every 10 minutes (rounded up to the nearest 10), display a bento box emoji. For example, if the article takes 35 minutes to read, you should display "🍱🍱🍱🍱 35 min read". If the article takes 61 minutes to read, you should display "🍱🍱🍱🍱🍱🍱🍱 61 min read".
**
And to solve that requirement I wrote the following code:
Anybody with suggestions for: **I am still trying to get into the habit of having a consistent time for studying and trying to wrap my head around, Whether I should learn React(Frontend Dev), Flask(BackendDev), and EthicalHacking(TryHackMe)
** | francis_ngugi |
1,873,129 | Mastering Modern UI Development: A Comprehensive Guide to Using Material-UI with React | Material-UI (MUI) is a robust React UI framework that effectively incorporates Google’s Material... | 0 | 2024-06-01T16:23:44 | https://dev.to/christopherthai/mastering-modern-ui-development-a-comprehensive-guide-to-using-material-ui-with-react-9d6 | webdev, react, ui, tutorial | Material-UI (MUI) is a robust React UI framework that effectively incorporates Google’s Material Design principles into React development. This design language, developed by Google, aims to create a harmonious experience across all platforms and devices, emphasizing clean, modern aesthetics and intuitive user interactions. By embracing these principles, Material-UI empowers developers to create applications that are not only applicable but also visually appealing and user-friendly, enhancing the overall user experience.
One of the standout features of Material-UI is its comprehensive set of pre-designed components. These components range from essential elements like buttons and text fields to complex components like data tables and dialogs. Each component adheres to highly customizable Material Design guidelines, allowing developers to tweak styles, behaviors, and appearances to fit their needs. This flexibility means maintaining a consistent design language while tailoring your application to your brand’s unique aesthetic.
Material-UI also excels in responsiveness, an essential aspect of modern web applications. The components are designed to be responsive and out-of-the-box, which means they look great and function well on any device, whether a desktop, tablet, or mobile phone. This responsiveness is essential for delivering a seamless user experience across various screen sizes and resolutions.
##What is Material-UI?##
Material-UI is an open-source library of React components that implements Google’s Material Design guidelines. Material Design is a language developed by Google that focuses on creating a consistent and intuitive user experience across different platforms and devices. Material-UI provides a rich set of components that adhere to these design principles, enabling developers to build sophisticated UIs quickly and efficiently.
##Comprehensive Component Library##
One of the most significant advantages of Materials is its extensive component library. This library includes various pre-designed components, from essential elements such as buttons, icons, and text fields to more complex components like data tables, dialogs, and navigation bars. Each component is designed with Material Design principles in mind, ensuring that it looks great and provides a consistent user experience.
##Customization and Theming##
Material UI components are highly customizable. Developers can effortlessly change the appearance and behavior of these components to fit their specific requirements. This customization is facilitated through a robust theming system that allows changes in color schemes, typography, spacing, and more. By creating custom themes, developers can ensure that their application matches their brand’s unique aesthetic while maintaining a consistent design language throughout the application.
##Responsiveness Out-of-the-Box##
In today’s digital landscape, users access web applications from various devices, including desktops, tablets, and smartphones. Therefore, ensuring an application is responsive and functions well across different screen sizes is crucial. Material-UI components are designed to be responsive out-of-the-box. This means developers do not need additional effort to ensure their applications are accessible and user-friendly on all devices. The components automatically adjust their layout and size based on the screen resolution, providing a seamless user experience.
##Community and Support##
Material-UI benefits from a large and active developer community. This community contributes to the continued betterment and expansion of the library by providing feedback, reporting issues, and creating new components. As a result, Material-UI is constantly evolving, with regular updates that present new features, enhancements, and bug fixes. The extensive documentation and numerous tutorials make it easy for developers to start with Material-UI and quickly become proficient in using its components.
##Setting Up Material-UI in a React Project##
To use Material-UI in a React project, you must first set it up. Here’s a step-by-step guide:
**Creating a React Project:** If you don’t have a React project, you can make one using the Create React App.
```
npx create-react-app my-material-ui-app
cd my-material-ui-app
```
**Install Material-UI:** Install the core Material-UI package and the Material-UI icons package.
```
npm install @mui/material @emotion/react @emotion/styled
npm install @mui/icons-material
```
##Using Material-UI Components##
Material-UI components can be imported and used in your React components. Here’s an example of how to use some essential Material-UI components:
###Button Component###
To use a button component, import it from `@mui/material` and use it in your JSX.
```
import React from 'react';
import Button from '@mui/material/Button';
function App() {
return (
<div>
<Button variant="contained" color="primary">
Hello World
</Button>
</div>
);
}
export default App;
```
This will render a primary-colored button with the text “Hello World.”
###Typography Component###
Material-UI’s Typography component is used for text elements.
```
import React from 'react';
import Typography from '@mui/material/Typography';
function App() {
return (
<div>
<Typography variant="h1" component="h2">
Welcome to My App
</Typography>
<Typography variant="body1">
This is a simple example of using Material-UI components.
</Typography>
</div>
);
}
export default App;
```
###Grid Layout###
Material-UI provides a powerful grid system for creating responsive layouts.
```
import React from 'react';
import Grid from '@mui/material/Grid';
import Paper from '@mui/material/Paper';
function App() {
return (
<Grid container spacing={3}>
<Grid item xs={12} sm={6}>
<Paper>Left Side</Paper>
</Grid>
<Grid item xs={12} sm={6}>
<Paper>Right Side</Paper>
</Grid>
</Grid>
);
}
export default App;
```
This code creates a responsive grid layout with two columns stacked on smaller screens.
###Theming with Material-UI###
Material-UI allows for extensive theming, enabling you to customize the appearance of your application to match your brand. Here’s how you can make a custom theme:
###Create a Theme###
Use the `createTheme` function to define a custom theme.
```
import { createTheme, ThemeProvider } from '@mui/material/styles';
import CssBaseline from '@mui/material/CssBaseline';
import App from './App';
const theme = createTheme({
palette: {
primary: {
main: '#1976d2',
},
secondary: {
main: '#dc004e',
},
},
});
function ThemedApp() {
return (
<ThemeProvider theme={theme}>
<CssBaseline />
<App />
</ThemeProvider>
);
}
export default ThemedApp;
```
###Apply the Theme###
Wrap your application with the `ThemeProvider` and pass your custom theme to it.
```
import React from 'react';
import ReactDOM from 'react-dom';
import ThemedApp from './ThemedApp';
ReactDOM.render(
<React.StrictMode>
<ThemedApp />
</React.StrictMode>,
document.getElementById('root')
);
```
##Conclusion##
Material-UI is a powerful and versatile framework that simplifies the process of building modern, responsive, and aesthetically pleasing web applications. By providing a rich set of components and extensive customization options, Material-UI enables developers to create applications that are not only functional but also visually appealing. Its integration with React makes it ideal for front-end developers who adhere to Material Design principles while leveraging React’s capabilities.
In this blog, we have delved into the benefits of Material-UI and provided practical guidance on how to use it effectively in React projects. We have covered the essentials of setting up Material-UI, demonstrated how to utilize its rich component library, and explored advanced features such as theming and customization. By harnessing the power of Material-UI, developers can create high-quality, modern web applications that adhere to best design practices and provide a seamless user experience across all devices. | christopherthai |
1,873,125 | Square and Fair: The Role of Square Images in Deep Learning | In the realm of deep learning, especially when working with convolutional neural networks (CNNs), you... | 0 | 2024-06-01T16:20:37 | https://dev.to/supreethmv/square-and-fair-the-role-of-square-images-in-deep-learning-2i7m | deeplearning, machinelearning, datascience, ai |
In the realm of deep learning, especially when working with convolutional neural networks (CNNs), you might have noticed that square images are often preferred. This preference isn't arbitrary; it stems from several practical considerations that enhance the efficiency and simplicity of neural network architectures. In this blog, we will explore the reasons behind this preference and illustrate the concepts with Python code examples.
Let's break down the main points and include Python code snippets to justify each statement.
---
## 1. Streamlined Convolutional Operations
Many CNN architectures leverage convolutional operations, applying filters or kernels to local regions of an input image. Square input dimensions simplify these operations by ensuring that the filters can efficiently traverse the entire image without complications associated with uneven dimensions.
### Python Example:
```
import torch
import torch.nn as nn
# Example convolution operation
conv = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, stride=1, padding=1)
input_image = torch.randn(1, 1, 28, 28) # Square image: 28x28
output = conv(input_image)
print(f"Output shape for square input: {output.shape}")
```
This code demonstrates how a convolutional layer processes a square input image, ensuring consistent traversal.
---
## 2. Efficient Parameter Sharing
CNNs benefit from parameter sharing, where the same filter weights are applied across different regions of the input. Square images provide a consistent grid structure, facilitating parameter sharing and ensuring that learned features generalize well.
### Python Example:
```
# Continuing from the previous example
filters = conv.weight.data
print(f"Filter shape: {filters.shape}")
```
Here, the filter shape remains consistent, allowing parameter sharing across the square image.
---
## 3. Simplified Pooling Operations
Pooling layers, such as max pooling or average pooling, are used in CNNs to downsample feature maps and reduce spatial dimensions. Square images make pooling operations straightforward and uniform, simplifying the reduction process.
### Python Example:
```
pool = nn.MaxPool2d(kernel_size=2, stride=2)
pooled_output = pool(output)
print(f"Pooled output shape: {pooled_output.shape}")
```
This code snippet shows max pooling on a square input, demonstrating the uniform reduction in dimensions.
---
## 4. Compatibility with Pre-Trained Models
Many pre-trained CNN architectures and models are designed to handle square input shapes. Using square images ensures compatibility with these architectures, making it easier to leverage pre-trained models.
### Python Example:
```
from torchvision import models
# Example using a pre-trained model
model = models.resnet18(pretrained=True)
input_image = torch.randn(1, 3, 224, 224) # Square image: 224x224
output = model(input_image)
print(f"Output shape for ResNet with square input: {output.shape}")
```
This demonstrates compatibility with a pre-trained ResNet model, which expects square input images.
---
## 5. Regularization Techniques
Data augmentation involves applying random transformations to input images during training. Square images simplify the implementation of these techniques, ensuring consistent transformations.
### Python Example:
```
from torchvision import transforms
# Example data augmentation pipeline
transform = transforms.Compose([
transforms.RandomRotation(30),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
])
# Apply transformations to a sample image
from PIL import Image
sample_image = Image.open('sample.jpg').resize((224, 224)) # Ensure the image is square
transformed_image = transform(sample_image)
```
Here, the transformations are consistently applied to a square image.
---
## 6. Aligning with Standard Image Sizes
Square images are commonly encountered in standard image sizes, making them a convenient choice for a wide range of applications, datasets, and image sources.
### Example:
Standard datasets like MNIST (28x28) and ImageNet (224x224) use square images, highlighting their widespread use and compatibility.
---
## Conclusion:
While square images offer several advantages, neural networks can handle non-square images as well. The choice of image dimensions often depends on the specific requirements of the task and the architecture being used. However, the simplicity and compatibility associated with square images make them a preferred choice in many deep learning applications. | supreethmv |
1,873,108 | Performance Optimization in Flask: Tips and Tricks for Making Flask Applications Faster and More Scalable | When working with Flask, a well-regarded Python micro-framework, performance optimization becomes... | 0 | 2024-06-01T16:13:30 | https://dev.to/christopherthai/performance-optimization-in-flask-tips-and-tricks-for-making-flask-applications-faster-and-more-scalable-45e8 | flask, python, webdev, learning | When working with Flask, a well-regarded Python micro-framework, performance optimization becomes crucial as your web application begins to scale. Flask is favored for its straightforward and flexible design, making it an excellent choice for quickly developing web applications of small to medium size. However, as the complexity of your application increases alongside its user traffic, you may start to notice performance bottlenecks. These issues can hurt the overall efficiency of your application, leading to slower response times, increased server load, and potentially, a negative impact on user experience and scalability.
To address these challenges, it’s essential to implement several optimization strategies to enhance your Flask applications’ speed and scalability. These strategies include efficient database query management, caching frequently requested data, utilizing asynchronous programming techniques, and applying best practices in code optimization. Focusing on these areas can improve your application’s responsiveness and more effectively manage larger traffic volumes.
Also, profiling your application to identify slow-running functions and critical resource-intensive areas can provide insights into where optimizations are most needed. Implementing a load-balancing function solution can distribute traffic evenly across multiple servers, further improving performance.
Adopting these tips and tricks will help keep your Flask application running smoothly and ensure that it can handle growth in user numbers and data processing demands. Thus, maintaining an efficient, scalable web application becomes feasible, paving the way for sustained success in your software engineer career.
##Profiling Your Flask Application##
Before you begin optimizing, it’s crucial to identify the bottlenecks. Profiling helps you comprehend which parts of your application are slow and why. Tools like Flask-Profiler or the Python module cProfile can be integrated into your Flask application to gather detailed performance data.
**Code Examples:**
```
from flask import Flask
import cProfile, pstats, io
app = Flask(__name__)
import cProfile
import io
import pstats
def profile():
"""
A context manager that profiles the code within its block and prints the profiling results.
Usage:
with profile():
"""
pr = cProfile.Profile()
pr.enable()
yield
pr.disable()
s = io.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats("cumulative")
ps.print_stats()
print(s.getvalue())
@app.route("/")
def home():
with profile():
return "Hello, World!"
if __name__ == "__main__":
app.run(debug=True)
```
##Database Optimization##
Database access is often the most significant bottleneck in web applications. Optimizing database queries and ensuring your database server is configured correctly are crucial steps.
* **Use Indexes:** Ensure your database queries are optimized with the correct indexes. This can drastically reduce query time.
* **Connection Pooling:** Utilize connection pooling to reduce the overhead of repeatedly connecting to the database. Flask extensions like Flask-SQLAlchemy support connection pooling.
**Code Examples:**
```
from flask_sqlalchemy import SQLAlchemy
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///yourdatabase.db"
db = SQLAlchemy(app)
# Example model definition for a User model
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
# Using the model in a route handler function
@app.route("/users/<int:user_id>")
def get_user(user_id):
user = User.query.get(user_id)
return {"username": user.username}
```
##Caching##
Caching improves the response time of your Flask application by storing the results of costly operations. Flask-Caching is a popular extension that provides an easy-to-use caching mechanism.
* **Cache static content:** Use cache headers or CDNs for static content like JS, images, and CSS files.
* **Cache dynamic content:** Cache database query results or whole views if they don’t change often.
**Code Examples:**
```
from flask import Flask
from flask_caching import Cache
app = Flask(__name__)
cache = Cache(app, config={"CACHE_TYPE": "simple"})
# Cache the view for 50 seconds
@app.route("/")
@cache.cached(timeout=50) # Cache this view for 50 seconds
def index():
return "Hello, Cached World!"
if __name__ == "__main__":
app.run(debug=True)
```
##Middleware and Request Optimization##
Middleware can add unnecessary overhead to each request. Evaluate and minimize the middleware you use.
* **Streamline middleware:** Only use essential middleware.
* **Optimize JSON parsing:** If dealing with JSON data, ensure efficient parsing and serialization.
**Code Examples:**
```
from flask import Flask, request, jsonify
app = Flask(__name__)
# A simple route that accepts POST requests with JSON data at /data
@app.route("/data", methods=["POST"])
def data():
data = request.get_json()
# Process your data here
return jsonify(status="success", data=data)
if __name__ == "__main__":
app.run(debug=True)
```
##Asynchronous Handlers##
For operations bound by input/out constraints or those that suffer from high latency, it’s beneficial to incorporate asynchronous elements into your application. Starting from version 2.0, Flask has enhanced its capabilities by supporting asynchronous route handlers. This feature allows parts of your application that handle extensive data transactions or are delayed by external systems to operate without blocking the entire application’s workflow. Implementing asynchronous patterns streamlines these interactions and improves overall responsiveness and user experience. By adopting asynchronous route handers in Flask, you can notably boost the efficiency of your web application, especially in handling concurrent requests and managing heavy traffic scenarios effectively.
**Code Examples:**
```
from flask import Flask
app = Flask(__name__)
# A simple route that returns a string response when the URL is visited with a GET request method
@app.route("/async")
async def async_view():
# Perform asynchronous operations like HTTP requests or I/O tasks
return "This is an async route!"
if __name__ == "__main__":
app.run(debug=True)
```
##Load Testing##
Regular testing under simulated load conditions is essential to gauge how modifications impact the performance of your application. Tools such as Locust or Apache JMeter are invaluable, as they can mimic the behavior of thousands of concurrent users interacting with your application. This simulation helps identify performance bottlenecks and areas needing optimization to handle high traffic efficiently. By consistently testing with these tools, you can observe the effects of change in real-time, allowing for proactive enhancement and adjustments. This practice ensures that your application remains robust under pressure and enhances user satisfaction by providing a responsive and smooth experience even during peak usage.
##Conclusion:##
Optimizing a Flask application is a comprehensive process that combines several critical strategies to ensure it remains fast and scalable. This approach involves detailed profiling to identify and eliminate bottlenecks in the code. Practical database tuning is essential, ensuring that data retrieval and storage are optimized to handle increased loads efficiently. Implementing caching mechanisms allows regularly accessed data to be stored temporarily, notably reducing retrieval times and server loads.
Moreover, efficient middleware management ensures that the components communicating between your application and the server are optimized for quick data processing. Asynchronous programming is another crucial element, enabling the application to perform multiple tasks concurrently, thus improving responsiveness and overall user experience. Regular load testing is also essential, as it helps simulate high-traffic conditions to see how the application behaves under stress, allowing for optimizations.
Adopting these strategies improves the performance of the Flask application as it grows, as well as its manageability and cost-effectiveness. This holistic optimization approach ensures that the application can handle growing user demands while maintaining a high level of performance, ultimately leading to a better user experience and reduced operational costs. | christopherthai |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.