teleren/devto huggingface dataset:
The Azure Storage Saga. Part 1
Published: 2024-01-15 21:04:58

## Introduction
This article is the first in a series that delves into different scenarios and use cases for configuring storage for an organization using Azure.

The given storage requirement is: "The IT department needs to prototype different storage scenarios and to train new personnel. The content isn’t important enough to back up and doesn’t need to be restored if the data is overwritten or removed. A simple configuration that can be easily changed is desired."

Based on this prompt, we will be creating a storage account with minimal configuration.

## Prerequisites
In order to complete this project, you will need an Azure account. If you do not currently have one, you can create a new one [here](https://portal.azure.com).

## Implementation
- In the Azure portal, click on the create a resource button

![Azure main page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jnxq5tlqviq03vy9rv4y.png)

- In the storage section, click on create storage account
![Resource Selection page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3m5n80im5bijym9qc2vz.png)

There are a couple of information that needs to be inputted here
- You can decide to create a new resource group as shown here or you can use an existing resource group
- Input a unique storage account name
- Pick a region close to you
- Based on the given requirements for the storage account, we do not need to use a Premium storage type. Select the standard storage type
- Make sure that the selected redundancy is Locally-redundant storage(LRS)
![Storage Account Creation Page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/g4paoj88r227l9m8gfp9.png)

- Make sure that Enable storage account access key is left unchecked. We do not need this feature because our requirement is a simple configuration.
- Click on review and wait for validation to be completed.

![Advanced Settings Page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kcry5edmt0aianqus5yb.png)
- Finally, click on create and wait for your storage account to be created
- After it has been successfully created, your storage account is ready to be created
![Created storage account page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gncge7jern1p3uq02euw.png)

### A Word On Clean-Up
It is recommended to delete your resources when they are no longer in use. This will prevent unused resources from accumulating unwanted costs. You can always recreate the resources when you need them later.
![Clean-up](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7d4w6t21va1bmxarkqg6.png)
5 ways to Shoot Yourself in the Foot With Typescript (And What To Do Instead) 🔫🦶🏽
Tags: webdev, beginners, typescript, programming
Published: 2024-01-15 20:16:09

TypeScript is great!

But as a beginner, there are at least 5 ways you can shoot yourself in the foot and end up with a broken app.

Find them below, along with what to do instead 👇🏽:

## Mistake #1: Using any recklessly 😵

Using `any` inadequately removes all the benefits of Typescript. 

For example, `(a, b) => a+b` won't catch bad arguments passed at compile time.

Instead, use the correct types,  unknown, or a mixed codebase (Javascript + Typescript).

## Mistake #2: Having `strictNullChecks` turned off 🔕

When turned off,  the following code will compile fine but fail in production.

```
function printUser(user: User) {...}
const me = users.find((u) => u.name === "Ndeye Fatou Diop")  
printUser(user) <- This will throw in if an user is not found
```

So make sure to turn it on.

## Mistake #3: Having `noUncheckedIndexedAccess` turned off 🔇

When turned off, the following code will compile fine but fail in production.

```
const usersByLocation = {"France": [], "USA": []}
usersByLocation["India"].push(...) <- This will fail
print(usersByLocation["France"][0].name) <- This will fail
```

So please do yourself a favor and turn it on.

## Mistake #4: Using the exclamation mark inappropriately 🫢

Using `!`, the non-null assertion operator, is rarely a good idea. Your code won't catch when the value is undefined.

Instead, handle null/undefined values properly or rewrite your code.

## Mistake #5: Abusing of type assertion 🤥

Using `value as MyType` is tempting when your code doesn't compile. But, this is risky because the type assertion may be false at runtime, leading to potential UI crashes.

Instead, use this sparingly and only in the relevant context.

---

That's it 😁

Thank you for reading this post 🙏, I hope it will help you in your journey!

Leave a comment 📩 and add other mistakes you made with TypeScript.

And Don't forget to Drop a "💖🦄🔥".

If you like articles like this, join my **FREE** newsletter, **[FrontendJoy](https://frontendjoy.substack.com/)**, or find me on [X/Twitter](https://twitter.com/_ndeyefatoudiop).
Your experience with esProc?
Tags: discuss, java
Published: 2024-01-15 19:43:56

I have recently learn about existence of [esProc SPL](https://www.scudata.com/). Looks like a (potentially) powerful data processing tool in Java. But I am a bit confused. There are quite a lot mentions from indivudal developers and like all of them seem totally positive. Yet it remains under the radar of more established info sources. Maybe it is because it didn't make a breakthrough here in Western world yet, as the company behind it hails from China?

Have you heard about it? Worked with it? What do you think? :eyes:
What is INP Interaction to Next Paint (INP) Core Web Vitals and how we can optimize?
Published: 2024-01-15 19:37:10

**INP (Interaction to Next Paint)** is a critical Core Web Vitals metric, set to replace First Input Delay (FID) in **March 2024**. It assesses a page's responsiveness to user interactions, focusing on minimizing the time between interaction and the next frame paint for swift visual feedback. Calculated through the observation of user interactions, INP provides a comprehensive view of a page's interactive performance.

The calculation involves excluding outliers to ensure accuracy, with the **75th percentile** filtering results for majority representation. A **good INP score**, measured at the 75th percentile across mobile and desktop devices, is below or at **200 milliseconds** for optimal responsiveness, **200-500 milliseconds** for improvement, and above 500 milliseconds for **poor** responsiveness.

**Explore a comprehensive** understanding of **INP** by [clicking here]
(https://www.linkedin.com/pulse/optimizing-user-interaction-next-paint-inp-core-web-vitals-muhammad-xotrf?trackingId=xR6zgtllR%2Byn3NCZGYI1Cw%3D%3D&lipi=urn%3Ali%3Apage%3Ad_flagship3_detail_base%3B7FCh1pbnSzywJFGohZsAEw%3D%3D) for an in-depth exploration of this crucial **metric** and its **impact** on **web performance**.

#CoreWebVitals #WebPerformance #PageExperience #LCP #FID #CLS #SEO #WebDev #UserExperience #GoogleUpdate #SiteSpeed #Optimization #WebDesign #FrontendPerformance #UXDesign #PageSpeed #WebsiteHealth

[See my portfolio](https://zain-muhammad.github.io/)
A frontend for your node.js installs
Tags: node, javascript, webdev, frontend
Published: 2024-01-15 19:35:39

It's been a while since I've reached out with an update, and today, I want to focus on a concept that is central to our work at WebCrumbs: Frontend for Backend (FFB) in the context of Node.js.

**Frontend for Backend (FFB): A Primer**

The idea of Frontend for Backend (FFB) revolves around creating user interfaces that directly interact with the backend – in our case, Node.js. 

This approach is about building a frontend layer that deeply connects with backend services, providing a more integrated coding experience.

**WebCrumbs: Bridging the Gap in Node.js**

{% cta https://github.com/webcrumbs-community/webcrumbs %} Star our GitHub to support our work! ⭐️ {% endcta %}

WebCrumbs is designed to facilitate this FFB approach for Node.js. By offering a range of plugins, WebCrumbs aims to simplify the process of creating websites that interact effectively with Node.js backends. Our goal is to make it easier for developers to add complex functionalities without getting bogged down in technical details.

**Why Plugins are Key**

Plugins are the heart of the WebCrumbs approach to FFB. They enable developers to easily implement features that are traditionally challenging, such as real-time data handling, user authentication, or interactive UI components, while ensuring they work seamlessly with the Node.js backend.

**Community-Driven and Open Source**

Being a community-driven, open-source project, WebCrumbs is constantly evolving with contributions from developers worldwide. This collaborative effort ensures that our FFB solutions are robust, versatile, and aligned with the latest industry practices.

{% cta https://github.com/webcrumbs-community/webcrumbs %} Contribute to our open-source project {% endcta %}

**What WebCrumbs is poised to achieve**

- **Streamlined Integration**: Easily connect your frontend and backend.
- **Customizable Plugins**: Tailor your Node.js applications with diverse functionalities.
- **Community Support**: Gain insights and assistance from a global network of developers.
- **Open-Source Flexibility**: Adapt and evolve solutions to fit your specific requirements.

**Final Thoughts on FFB with WebCrumbs**

FFB represents a shift in how we think about building web applications. It's about creating and editing your website with a no-code interface that is not only visually appealing but also deeply integrated with backend processes. With WebCrumbs, this integration is not only possible but also simpler and more accessible.

WebCrumbs stands as a testament to this new approach, bridging the gap between frontend and backend in the Node.js ecosystem.
New Year, New Dev, New Me: My #DEVResolutions2024
Tags: devresolutions2024, beginners, webdev, javascript
Published: 2024-01-15 19:30:12



## Professional Goals:

 **Build a portfolio website:**

- A developer without a portfolio is like a knight without armor – vulnerable and ineffective. So, this year, I'm building my digital suit of shining code: a portfolio website that showcases my skills, projects, and (hopefully) burgeoning brilliance.


**The Project Playground:**

- I'm committing to creating at least five projects this year. These won't be run-of-the-mill "Hello World"s – I'm talking about projects that push my boundaries, ignite my creativity, and maybe even solve a real-world problem or two (world domination not included... yet).

 
**Writing Blogs:**

- I'll be sharing my coding journey, technical insights, and maybe even the occasional hilarious debugging mishap (we've all been there!). My goal is to create content that resonates with the dev community, fosters learning and discussion, and maybe even inspires a few folks to pick up coding themselves


![cat coding meme](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/41p0k4xm3lf51v651fgu.gif)


## Personal Aspirations:

**Public Speaking:** 
 - I am confident but somehow when I am on the stage, I stand blank. I will work on myself to overcome this nervousness and be able to deliver my thoughts and ideas to the crowd listening. 

 **Going Out:**

- I am very introverted and that's why I like to stay in my room rather than interacting with people and going to social gatherings. I will try to touch grass more often

## DEV Community Contributions:

1. **Contribution Goal:**

- I'd like to learn and make use of my skills by contributing to interesting projects through the dev community. I am still new to this and got a long way to go, and I am on it.
Dockerizing a Java Application with Spring and Maven
Tags: docker, spring, java, shell
Published: 2024-01-15 18:52:38

Docker has become an essential tool for developers, enabling the creation, deployment, and execution of applications in lightweight and portable containers. In this simple guide, we will explore how to dockerize a Java application using Spring and Maven.

## Prerequisites:
Before we begin, make sure you have Docker and Docker Compose installed on your machine. You can download them from the official Docker website (https://www.docker.com/get-started).

## Step 1: Project Structure
Organize your Spring project following a conventional structure. Make sure to have a pom.xml file to manage dependencies with Maven.

## Step 2: Dockerfile Configuration
Create a file called Dockerfile in the root of your project. This file contains the necessary instructions to build the Docker image of your application. Here's a basic example:

```
# Use the OpenJDK base image
FROM openjdk:11

# Set the working directory
WORKDIR /app

# Copy the JAR files and necessary resources to the container
COPY target/your-application.jar /app/your-application.jar

# Expose the port that the application is listening on
EXPOSE 8080

# Command to run the application when the container starts
CMD ["java", "-jar", "your-application.jar"]
```

Make sure to replace "your-application.jar" with the actual name of your JAR file generated by Maven.

## Step 3: Docker Image Build
Open the terminal in the root of your project and execute the following command to build the Docker image:

`docker build -t your-application:latest .`

This command uses the Dockerfile in the current directory (.) to build an image with the tag your-application:latest.

## Step 4: Container Execution
Now that the image has been successfully built, you can run a container of your application with the following command:

`docker run -p 8080:8080 your-application:latest`

This command maps port 8080 from the container to port 8080 on the host machine. Adjust as needed.

> By following these simple steps, you have dockerized your Java application with Spring and Maven. Your application is now encapsulated in a Docker container, providing portability and making dependency management easier. Be sure to explore more Docker features and adjust as needed for your specific environment.
BetterDocs
Tags: webdev, javascript, beginners, programming
Published: 2024-01-15 18:51:15

[BetterDocs](https://www.wsovn.net/betterdocs) là gì ?
Tăng tốc sức mạnh của cơ sở tri thức với BetterDocs Tạo và quản lý tài liệu cơ sở tri thức một cách hiệu quả để giảm phiếu hỗ trợ, tăng năng suất, cải thiện trải nghiệm người dùng và mở rộng quy mô hoạt động hỗ trợ khách hàng của bạn.
FE – BetterDocs Unlimited – $147
Mẫu sẵn sàng tuyệt đẹp
Tạo trang đích cho trang tài liệu của bạn trong vài phút với bố cục sẵn sàng đẹp mắt và cung cấp giao diện thân thiện với người dùng mà không cần sử dụng bất kỳ mã nào.
Mục lục có thể cuộn
Tự động tạo Mục lục khi bạn sử dụng các dấu đầu dòng trong các bài viết trợ giúp và làm cho TOC này di chuyển bằng cách cuộn để cho phép khách truy cập của bạn luôn chuyển đến phần khác của tài liệu.
Mua ngay tại: [https://www.wsovn.net/betterdocs](https://www.wsovn.net/betterdocs)
OCI Observability and Management for Multi-Cloud Database: Amazon RDS
Tags: cloud, oci, aws, softwaredevelopment
Published: 2024-01-15 18:36:32

Multi-cloud has gained importance in recent years as companies distribute their workloads across multiple cloud providers per their unique preferences and convenience.

This blog explains how OCI Observability and Management services, such as Database Management, Stack Monitoring, Operations Insights, and Logging Analytics are used for monitoring RDS database flavors running on Amazon AWS.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dovuzclxehgdarikdd7q.png)



https://blogs.oracle.com/cloud-infrastructure/post/oci-om-multicloud-database-amazon-rds?source=:so:ch:or:awr::::&SC=:so:ch:or:awr::::&pcode=
Três Pilares de um Código Excelente: Comunicação, Simplicidade e Flexibilidade
Published: 2024-01-15 18:09:32

No desenvolvimento de software, a excelência é muitas vezes definida por três valores fundamentais: comunicação eficaz, simplicidade na estrutura e flexibilidade para adaptação. Estes valores, embora possam parecer contraditórios em alguns momentos, se complementam na prática. Um código excelente é aquele que é robusto, facilmente extensível, livre de complexidades desnecessárias e compreensível para os desenvolvedores.


## Comunicação
A programação não se limita a conversar com o computador; ela envolve, crucialmente, a comunicação entre pessoas. Isso se traduz em códigos mais claros, fáceis de ler e com melhor custo-benefício. Pense sempre que seu código será mantido por alguém que não é você. Programar sem considerar os outros pode criar soluções que, embora brilhantes na mente do desenvolvedor, são confusas e difíceis de manter para outros.

Há um forte argumento econômico para focar na comunicação durante a programação. A maioria dos custos de software ocorre após sua implantação. Em minha experiência com refatoração, percebi que passava mais tempo entendendo o código existente do que escrevendo novo. Portanto, um código econômico é aquele que é fácil de ler.

## Simplicidade
Eliminar a complexidade excessiva é vital. Isso permite que programadores compreendam, utilizem e modifiquem o software mais rapidamente. Excesso de complexidade diminui o valor do software, prejudica a execução correta e complica mudanças futuras. Uma parte essencial da programação é avaliar o que foi feito e identificar o que é essencial e o que não é.

A simplicidade é subjetiva. O que é simples para um programador sênior pode ser complexo para um júnior. É saudável desafiar os programadores, mas a complexidade desnecessária é um obstáculo. A busca pela simplicidade fomenta a inovação.


## Flexibilidade
Como a maior parte do custo de um sistema ocorre após sua implantação, facilitar mudanças é crucial. Melhorar a comunicação no código aumenta sua flexibilidade. Quanto mais pessoas conseguirem ler, entender e modificar o código rapidamente, maior será a capacidade de adaptação a mudanças futuras. Considere que novas pessoas se juntarão à equipe e quanto mais rápido elas compreenderem o código, mais rapidamente poderão contribuir e agregar valor ao produto.

Escolha padrões que promovam flexibilidade e tragam benefícios imediatos, equilibrando desafios e simplicidade.


## Conclusão
A harmonia entre comunicação, simplicidade e flexibilidade é o que define um código de alta qualidade. Estes valores não apenas facilitam o desenvolvimento e a manutenção de software, mas também são essenciais para o sucesso e a sustentabilidade de projetos de software no longo prazo. Ao integrar esses princípios, desenvolvedores podem criar soluções mais robustas, adaptáveis e eficientes, beneficiando toda a equipe e, em última análise, o produto final
Crafting a new developer experience through user research 🧐
Tags: webdev, productivity, devops, testing
Published: 2024-01-15 18:02:13

Over the course of a year, we gathered feedback from developers to better understand some of their key challenges with our product.

This research helped us identify identified three key product areas to improve:

🏄 Streamlining onboarding and project creation
🧘 Providing flexible, container-based resource allocation 
🚀 Creating a usage-based billing model to cater to flexible resources

...And more.

These insights and the extensive research led us to build a new product, Upsun, with a wide range of new features and to enable functionality, onboarding, and configuration for any application.

Read our full journey to **[crafting a new developer experience through user research.](https://upsun.com/blog/crafting-a-new-developer-experience-through-user-research/?utm_source=social&utm_medium=organic-social&utm_campaign=upsun-blog-2023)**
time-speak: A Node.JS Library For Parsing Dates and Durations 🚀🕒
Tags: javascript, typescript, node, programming
Published: 2024-01-15 17:53:51

> Get time-speak here on npm

While working on [**track-time-cli**](https://dev.to/f3rno64/a-powerful-nodejs-cli-time-tracker-1fb0), I encountered the need for a library to parse dates and intervals, so natural language could be used to specify time sheet entry start & end dates. For example, `tt in --at 'three hours ago' some task`

I went ahead and wrote a tiny library for this, [**time-speak**](https://www.npmjs.com/package/time-speak). It is nearly dependency-free, with just one requirement of [**numbers-from-words**](https://www.npmjs.com/package/numbers-from-words), another zero-dependency library of mine for parsing numbers from words (i.e. `parse('twenty three')`).

---

### Usage

To use, install it with `npm i --save time-speak` and import the parse method with either `import { parse } from 'time-speak'` or `import parse from 'time-speak'`, then just pass the parse method your input string.

Thanks to [**numbers-from-words**](https://www.npmjs.com/package/numbers-from-words), number words are supported in the input, so all of the following are valid inputs:

* "2 days and three hours ago"
* "in five weeks"
* "3 minutes ago"
* "24 hours"

Inputs specifying a date in the future (starting with "in") are parsed as such, while inputs ending in "ago" are parsed as dates in the past, relative to the present moment. Such inputs to parse return Date objects.

Inputs without the "in" prefix or "ago" suffix are parsed as durations, and the return value is the duration length in milliseconds, a number.

Here is an example taken from the docs:

```js
import { parse } from 'time-speak'

const pastDate = parse('2 days and 4 hours ago')
const pastDateWithNumberWords = parse('two days and four hours ago')
const futureDate = parse('in 4 hours')
const durationMS = parse('6 months')

console.log({
  pastDateWithNumberWords,    // 2023-12-19T13:02:39.768Z
  pastDate,                   // 2023-12-19T13:02:39.768Z
  futureDate,                 // 2023-12-21T21:02:39.768Z
  durationMS                  // 15552000000
})
```

---

That's it! Go ahead and start hacking!

Links:
* [Github](https://github.com/f3rno64/time-speak)
* [NPM](https://www.npmjs.com/package/time-speak)
XSLT
Tags: uyumsoft
Published: 2024-01-15 17:52:57

> XSLT, Suppress, Multi string
```
<xsl:for-each select="//n1:DespatchAdvice/cbc:Note">
<xsl:if test="not(contains(., 'Fatura Adresi')) and not(contains(., 'Sevk Adresi'))">
<b>&#160;&#160;&#160;&#160;&#160;&#160;Not: </b>
<xsl:value-of select="."/>
<br/>
</xsl:if>
</xsl:for-each>
```
WordCamp conferences: next meetings - an global overview
Tags: webdev, wordpress, beginners, productivity
Published: 2024-01-15 17:51:13

WordCamp is a conference that focuses on everything WordPress.
WordCamps are informal, community-organized events that are put together by WordPress users like you. 
Everyone from casual users to core developers participate, share ideas, and get to know each other.

see https://central.wordcamp.org

Upcoming WordCamps

WordCamp Zaragoza: 19 January–20 January

WordPress Web Challenge: 27 January

WordCamp Phoenix: 9 February–10 February

WordCamp Pune, India: 17 February

WordCamp Kansai 2024: 23 February–24 February



**WordCamp US 2024: What you need to know**
https://us.wordcamp.org/2024/ :: https://us.wordcamp.org/2024/location/

We’re happy to announce that WordCamp US 2024 is officially on the calendar!

**Location**
WordCamp US will be held at the Oregon Convention Center in Portland, Oregon: 777 NE Martin Luther King Jr Blvd, Portland, Oregon 97232 USA

**Schedule**
WordCamp US 2024 will take place September 17-20, 2024.

September 17-18: WordCamp US Contributor Days
September 19-20: WordCamp US programming days

see more data  https://central.wordcamp.org