teleren/devto huggingface dataset:
What Is ITIL 4 DPI
Tags: itil, training, certification, itilv4
Published: 2023-05-09 05:54:38

ITIL 4 DPI stands for "ITIL 4 Drive Stakeholder Value - Digital and IT Strategy". It is a module of the ITIL 4 certification scheme that focuses on how to create and deliver value through IT and digital services by understanding and engaging with stakeholders.
This module covers topics such as customer journey mapping, service level agreements, customer experience, communication and collaboration, digital transformation strategy, and service automation. It also explores how to align IT and digital strategy with business objectives and how to measure the success of digital and IT services.
ITIL 4 DPI is designed for IT professionals who are involved in managing customer relationships and delivering IT and digital services that meet the needs of their organization's stakeholders. It is an important module for those who are seeking to obtain the ITIL 4 Managing Professional (MP) certification.
ITIL 4 DPI stands for ITIL 4 Drive Stakeholder Value and is a module within the ITIL 4 certification scheme. ITIL (Information Technology Infrastructure Library) is a widely recognized framework for IT service management that provides guidance and best practices for the design, delivery, and improvement of IT services.
The ITIL 4 DPI module focuses on the ways in which organizations can create value through the delivery of services that meet the needs of their customers and stakeholders. It covers topics such as customer experience, communication, relationship management, and customer journey mapping.
The ITIL 4 DPI module is designed for IT service management professionals who are responsible for engaging with stakeholders and ensuring that their needs are met through the delivery of IT services. It is also relevant for individuals who are involved in customer experience management, marketing, and business relationship management.
The ITIL 4 DPI module is one of the intermediate-level modules in the ITIL 4 certification scheme and can be taken by individuals who have already completed the ITIL 4 Foundation certification.

Website: - The Knowledge Academy
You tube: - The Knowledge Academy
Best Practices When Designing AWS Architecture: Cost Optimization and Sustainability
Tags: aws, cloud
Published: 2023-05-09 05:54:00

The AWS Well-Architected Framework helps you understand the decisions you make while building workloads on AWS. The Framework provides architectural best practices for designing and operating reliable, secure, efficient, cost-effective, and sustainable workloads in the cloud1.

The AWS Well-Architected Framework is based on six pillars: 

- Operational Excellence
- Security
- Reliability
- Performance Efficiency
- Cost Optimization
- Sustainability 

This post focuses on the Cost Optimization and on the Sustainability pillars.

The Cost Optimization pillar includes the ability to run systems to deliver business value at the lowest price point. A cost-optimized workload fully utilizes all resources, achieves an outcome at the lowest possible price point, and meets your functional requirements.

By adopting the practices in this pillar you will build capability within your organization, design your workload, select your services, configure and operate the services, and apply cost optimization techniques.

This pillar provides an overview of design principles, best practices, and questions.

The Sustainability pillar focuses on environmental impacts, especially energy consumption and efficiency since they are important levers for architects to inform direct action to reduce resource usage. It provides design principles, operational guidance, best practices, potential trade-offs, and improvement plans you can use to meet sustainability targets for your AWS workloads.

By adopting the practices in this pillar you can build architectures that maximize efficiency and reduce waste.

This pillar provides an overview of design principles, best practices, and questions.

If you have any questions, feel free to reach out.
Introduction To Web Development
Tags: webcourses, courses, traininbg, certification
Published: 2023-05-09 05:42:54

**[Web development](https://youtu.be/iu_knUhkRAE)** is the process of producing websites or web applications on the internet. It consists of various processes, including designing the user interface, programming, testing, and deployment. Web developers employ many computer languages, tools, and frameworks to create visually appealing, responsive, and effective websites.
AWS IAM Role and Policies
Published: 2023-05-09 05:18:39

AWS IAM Role and Policies
IAM role and policies can be composed either via Visual Editor in AWS, or via plain JSON.


To follow the Least Privilege Principal, we can further restrict actions via Resource and Conditions.

To find the required Resource/Conditions for particular action, see:
https://iam.cloudonaut.io/reference/#/

For condition, you can use the service-specific string matching, such 

```
      "Condition": {
         "StringEquals": {
            "aws:ResourceTag/Department": "Test"
         }
      }
```
Ref:
https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_examples_ec2_securitygroups-vpc.html
Process Analytics Monthly Report - April 2023
Tags: news, rlang, analytics, typescript
Published: 2023-05-09 05:13:00

## **Process Analytics - April 2023 News**

Welcome to the Process Analytics monthly news 👋.

Our “always” reminder: The goal of the Process Analytics project is to provide a means to rapidly display meaningful Process Analytics components in your web pages using BPMN 2.0 notation and Open Source libraries.

In this edition, you'll find the details of the new bpmnVisualizationR package release and a refresh of the bpmn-visualization demo integrating with pm4py.  🤗 We're always looking for ways to improve your workflow, so read on for more details on these exciting developments!

## bpmnVisualizationR package

In April, we released a new version: [0.4.0](https://github.com/process-analytics/bpmn-visualization-R/releases/tag/v0.4.0). This new version allows you to choose the style and position of the overlays.

In earlier versions, the style and the position of the overlays were not configurable.

![Display overlays with default position and style](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vofu24bt7ul5yieg0qvy.png)
_Display overlays with default position and style_

Now, it is possible to change the position and the style of the overlays, like in the following screenshot 👇:

![Display overlays with a position and style change](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j6o09jvp3iogwb1os8si.png)
_Display overlays with a position and style change_

## Improvements in the bpmn-visualization pmp4py demo

Before pm4py 2.6.1, it was not possible to obtain statistics about the edges of the Petri net corresponding to the sequence flows of the BPMN diagram. This is a recurrent problem in the Process Mining community and a correction has been made in pm4py 2.6.1: [pm4py/pm4py-core@84e85c6](https://github.com/pm4py/pm4py-core/commit/84e85c6e4715fe58159f6cfb83248d1cfa28bc8e).

The demo has been updated to benefit from the fix and it is now able to display execution frequency on the sequence flows of the BPMN diagram 🥳.

![Display execution frequency on sequence flows](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y7g7itqyq0fjb8zytkl9.jpg)
_Display execution frequency on sequence flows_

## That’s All Folks!

We hope you enjoyed this “edgy” April project news and are looking forward to what the rest of the spring  will bring 👋.

In the meantime, stay on top of the latest news and releases by following us:

* Website: [https://process-analytics.dev](https://process-analytics.dev/?utm_source=dev.to&utm_medium=display&utm_campaign=news)
* Twitter: [@ProcessAnalyti1](https://twitter.com/ProcessAnalyti1)
* GitHub: [https://github.com/process-analytics](https://github.com/process-analytics)
* Discord: [Join our server!](https://discord.com/invite/HafnBYsRXd)
* YouTube: [Process Analytics YouTube channel](https://www.youtube.com/@process-analytics)

*Cover photo by [James Wheeler](https://unsplash.com/fr/photos/Ml10OqzzdyI) on[ Unsplash](https://unsplash.com/?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)*
O que é Vite e quais suas vantagens para projetos fron-end?
Published: 2023-05-09 05:09:42

Vite é uma ferramenta de desenvolvimento de front-end construída com base no ecossistema do JavaScript. Ela foi criada para melhorar a eficiência do desenvolvimento front-end, tornando-o mais rápido e mais fácil para os desenvolvedores. Neste artigo, vamos explicar o que é Vite, suas principais vantagens e desvantagens.

De onde saiu o Vite?

Vite é uma ferramenta de desenvolvimento de front-end criada pelo criador do Vue.js, Evan You. Ele descreveu Vite como "um construtor de aplicativos web mais rápido e mais leve para desenvolvimento de front-end moderno". Vite é uma ferramenta de build que visa melhorar a velocidade do desenvolvimento de front-end e é projetado para ser simples e fácil de usar.

Vite usa a funcionalidade do ECMAScript 6, que permite que os desenvolvedores criem aplicativos usando módulos JavaScript. Ele usa o sistema de módulos nativo do JavaScript, que é nativo nos navegadores modernos, permitindo que os desenvolvedores criem aplicativos sem precisar transpilar o código.

**Vantagens do Vite**

- **Velocidade de desenvolvimento**: A principal vantagem do Vite é a velocidade de desenvolvimento. Vite é projetado para ser rápido e leve, permitindo que os desenvolvedores criem aplicativos rapidamente e sem esforço. Ele suporta a atualização automática do navegador, que permite que os desenvolvedores visualizem as alterações em tempo real, sem precisar atualizar manualmente a página do navegador.

- **Fácil de usar**: Vite é projetado para ser fácil de usar. Ele tem uma configuração mínima e requer apenas alguns comandos para configurar e executar o aplicativo. Isso torna o desenvolvimento de front-end mais fácil para os desenvolvedores que estão começando no desenvolvimento de front-end.

- **Suporte para React**: O Vite é compatível com o React, tornando-o uma excelente opção para desenvolvedores que usam o React. Ele oferece suporte total ao React, tornando mais fácil para os desenvolvedores criar aplicativos React sem precisar configurar o ambiente de desenvolvimento. Além disso, o Vite é compatível com outras bibliotecas JavaScript populares, como Vue.js e Preact.
Survey About AI-Assisted Code Generation Tools
Tags: programming, webdev, python, productivity
Published: 2023-05-09 04:54:58

We are a research group under the direction of Prof. Doowon Kim at the University of Tennessee, Knoxville, in collaboration with Sungkyunkwan University, South Korea. We are looking to recruit participants with some experience in software development.

This survey is intended to better understand developers' perceptions of AI-assisted code generation tools (e.g., IntelliSense, GitHub Copilot, ChatGPT, etc.).

The survey asks a series of questions about your programming experience and general demographics.

The survey consists of three parts:

Part 1: Demographic questions

Part 2: Simple programming quiz

Part 3: Programming experience with AI-assisted code generation tools

You are eligible for this study if you:

Are at least 18 years old,

Have programming experience,

Are comfortable completing this study in English.

Participants have a chance to provide their contact information in the survey and win gift cards worth $60 (e.g., Amazon); there is a 1 in 20 chance of winning a gift card in the raffle. Please note that your email address will only be used for payment of the reward, and will be removed from the dataset after the study.

[The online survey URL](https://docs.google.com/forms/d/1jbiMERjZMglDFgOXfrytmDtCJktiRiI15lcJg94CNHI/edit?ts=643965b0)

We look forward to hearing your thoughts on code-generation tools!

Thank you
Trailing Slash in Laravel
Published: 2023-05-09 04:17:24

A trailing slash refers to the forward slash (/) character that appears at the end of a URL or directory path. It is called a "trailing" slash because it comes after the last character in the string.

In the context of a URL, the trailing slash indicates that the URL represents a directory or a folder rather than a specific file. For example, "www.thulo.com/about/" represents the "about" directory on the website.It is also  used to indicate that the path refers to a directory rather than a file. Example "/home/user/Documents/" represents the "Documents" directory in the file system.

The presence or absence of a trailing slash in a URL can have implications for SEO (Search Engine Optimization). Some considerations of it are :

1. Canonicalization - SEO treat URLs with and without trailing slashes as separate pages.

2. Link equity distribution - If a website has both versions of a URL (with or without trailing slash) , it shows link equity dilution.

3. URL consistency -  Having a consistent URL structure is important for user experience and search engine crawlers

4. User behavior and sharing - The presence or absence of a trailing slash can affect how users perceive and share URLs.

Now, Let know how to remove and add trailing slash.

In Laravel, we can remove or add a trailing slash to a URL using the url() helper function and the trim() function provided by PHP.

> Remove trailing slash from a URL
`$url = rtrim(url('/'), '/');
`

> Add from trailing slash a URL
`$url = rtrim(url('/'), '/') . '/';
`

Also ,  we can add and remove trailing slashes using an '.htaccess' file in laravel. 

> Remove trailing slash from .htaccess file
`# Remove trailing slash
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)/$ /$1 [L,R=301]
`

> Add trailing slash from .htaccess file 
`# Add trailing slash
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_URI} !(.*)/$
RewriteRule ^(.*)$ /$1/ [L,R=301]
`

In conclusion, a trailing slash refers to the forward slash (/) character that appears at the end of a URL or directory path. While it may not have a significant impact on SEO, it's essential to consider a consistent URL structure and handle trailing slashes appropriately to improve user experience and avoid duplicate content issues.
Array.map(JavaScript array method) under the hood
Tags: javascript, javascriptmethod, webdev, beginners
Published: 2023-05-09 04:14:30

`Array.map()` is a useful built-in function in JavaScript that is used to create a new array by applying a transformation function to each element in an existing array. The `map()` function takes two arguments, one an array and the other a callback function that specifies how each element in the array should be transformed.

In this article, we will dive under the hood and explore how the `map()` function works in JavaScript.

**The basics of map()**
Before we dive into the technical details of how `map()` works, let's start by reviewing the basic syntax and usage of the function. Here's an example of how `map()` can be used to create a new array of squared values:

```
const originalArray = [1, 2, 3, 4, 5];

const squaredArray = originalArray.map((element)=> element * element; );

console.log(squaredArray); // Output: [1, 4, 9, 16, 25]
```

In this example, we start with an array of numbers and use the `map()` function to create a new array where each element is the square of the corresponding element in the original array.

**How map() works under the hood**
Now let's take a closer look at how the `map()` function works behind the scenes.

When you call `map()` on an array, JavaScript creates a new array with the same length as the original array but never change(mutate) the origanal array. The new array is initially empty, but JavaScript will fill it in with values as it iterates through each element in the original array.

For each element in the original array, `map()` calls the callback function that you passed as an argument. This callback function takes three arguments:

1. The current element being processed

2. The index of the current element

3. The original array that map() was called on

The callback function returns a new value that should be used for the corresponding element in the new array. Once the callback function has been called for every element in the original array, `map()` returns the new array.

Here's a simplified version of what happens under the hood when you call `map()`

```
function map(array, callback) {

const newArray = [];

for (let i = 0; i < array.length; i++) {

const currentElement = array[i];

const transformedElement = callback(currentElement, i, array); newArray.push(transformedElement);

}

return newArray;

}

```

This code is a simplified version of what happens when you call `map()`. In reality, the `map()` function is implemented more efficiently and with more error checking, but this code captures the basic idea.

**Conclusion**
The `map()` function is a powerful tool that makes it easy to transform arrays in JavaScript. By understanding how `map()` works under the hood, you can better appreciate the elegance and efficiency of this built-in function. Whether you're working on a small JavaScript project or a large-scale web application, `map()` is a valuable tool to have in your arsenal.
Writing Single Page Application With Nim 👑
Tags: nim, beginners, webdev, tutorial
Published: 2023-05-09 04:13:07

## Why Nim 🤔
Nim is powerful programming language that compiles into C, Cpp, ObjC and JS (what we need).

You can install it [here](https://nim-lang.org/install.html)

## HappyX ✨
HappyX is an asynchronous web framework, written in Nim.
[Source code](https://github.com/HapticX/happyx)
We'll work with it.
```bash
nimble install happyx
```

## Getting Started 👔
You should create project. Choose project name and mark project type as `SPA`.
```bash
hpx create
```

You should move into project folder after this.
```bash
cd PROJECT_NAME
```

## Development 🛠
Let's launch project.
```bash
hpx dev --reload
```

The `dev` command will hosts our project at `localhost:5000`.
Flag `--reload` will checks all changes in project.

> Also you can use flags `--host=0.0.0.0` and `--port:1234` 💡

Now you can change anything and see result in opened web page! 🙂

Let's change `main.nim`. For it you should open `src/` folder and open `main.nim` file. You will see
```nim
import
  happyx,  # import main library
  components/[hello_world]  # import components

# Binds single page application to element with id "app"
# In our case - <div id="app"></div>
# Command `hpx create` reproduce all need files
appRoutes("app"):
  "/":  # Route our app
    component HelloWorld  # It is a component usage
```

Try to change ``"/"`` route
```nim
"/":
  component HelloWorld
  tButton:  # tButton will reproduce <button> tag
    "Click me!"  # This will reproduce only text
    @click: # This will handle button clicks
      # Here you can use real Nim code 💡
      # As example you can write in browser console
      echo "Clicked!"
```
OK, save it and see result! 🙂

## Component Development 🛠
Move into `src/components/` folder. Here automatically created component `hello_world.nim`

```nim
import happyx  # Import main library

# component declaration
component HelloWorld:
  `template`:  # HTML part 📕
    # Here you can write HTML
    "Hello, world!"
 
  `script`:  # Script part, optionally 🛠
    # Here you can use real Nim code 💡
    echo "Start coding!"
  
  # Also can be `style` part with component styles 🎴
  # `style`:
  #   """
  #   div {
  #     background: gray;
  #   }
  #   """
```

That's all! Good Luck! 🙂

Also you can read about [API in Nim](https://dev.to/ethosa/writing-api-in-nim-58k4)
A Night of Coding Triumph: Unmatched Progress and Flawless Undo Button!
Tags: javascript, programming, react, python
Published: 2023-05-09 04:11:04

Hey folks! Just wanted to share the excitement of my coding adventure last night. I was in the zone for hours, starting at 10 PM and pushing through till 6 AM. Can you believe it? The sun is already up here in Sweden!

So, let me give you the highlights: I made some fantastic progress on my project. First, I implemented an “unmatch” feature, allowing users to remove unwanted matches. I also created a separate array for unmatched users and set up a filter to exclude them from new matches and from new users to swipe on.

Now, it’s time for some well-deserved rest. I can’t wait to tackle new challenges and make more progress in the coming days. Stay tuned for more updates on my coding journey!
57 berufliches Vorwärtskommen: Werbung fürs Trainieren der emotionalen Intelligenz als Software-Entwickler.
Tags: deutsch, career, motivation, discuss
Published: 2023-05-09 03:59:00

Moin Moin,

ich suche ab sofort Software-Entwickler, IT-Abteilungen und insbesondere dich zu gewinnen fürs Trainieren der emotionalen Intelligenz.

Als Software-Entwickler sind wir für gewöhnlich viel damit beschäftigt uns fortzubilden. Oft wechseln wir auch [die Rollen ( oder „Orte“ )→](https://dev.to/amustafa16421/52-berufliches-vorwartskommen-eine-klare-rolle-im-software-entwicklungsprojekt-3e3k), die wir in Projekten innehaben ( Rollen jedoch nicht während eines Projekts, außer wie im [vorherigen Beitrag→](https://dev.to/amustafa16421/56-berufliches-vorwartskommen-wie-sieht-zureichende-emotionale-intelligenz-bei-software-entwicklern-aus-2971) ).
Dies erfordert unter anderem, dass man sich „kopftechnisch“ weiterbildet. Ich werbe dafür, dass wir unsere „Herzen“ nicht vernachlässigen, uns also _herztechnisch_ weiterbilden.

Dies kann Spannungen in Teams reduzieren, die Beziehungen die man pflegt verbessern und insgesamt zu einer besseren Selbstbeherrschung führen.
Ich werbe also fürs Trainieren der Selbstwahrnehmung, der Gefühlsverwaltung, des Einfühlungsvermögens und der Beziehungsverwaltung.

1) Meinst du, dass wir emotionale Intelligenz vermehrt bei unserer Arbeit benötigen? ( 5-Sterne-Maß ), 
Ausführungen willkommen.
2) Hast du Schwierigkeiten beim üben? Wenn ja, welche?
Wenn nein, wie gehst du dabei vor?

Lass uns mittels Kommentaren austauschen.

Beste Grüße,
Mustafa

Austausch mittels E-Mail: mustafa.kevin.dwenger@posteo.de
Betreff: Austausch
Why are the output results inconsistent after assigning values to the same data type？
Tags: python
Published: 2023-05-09 03:47:23

# create test_dict
test_dict = {'tom': {"Chinese": [], "Math": [], "English": []}, 'lily': {"Chinese": [], "Math": [], "English": []}}

# create test_dict1
items = {"Chinese": [], "Math": [], "English": []}
test_dict1 = dict.fromkeys(["tom", "lily"])
for name in ['tom', 'lily']:
    test_dict1.update({name: items})
print('test_dict1:', test_dict1)

# Assign to test_dict、test_dict1
result = [('tom', 90, 85, 92), ('lily', 80, 96, 91), ('tom', 90, 85, 92), ('tom', 97, 89, 88)]
for i in result:
    name = i[0]
    print(test_dict)
    print(test_dict1)
    for item in items.keys():
        test_dict[name][item].append(i[list(items).index(item)+1])
        test_dict1[name][item].append(i[list(items).index(item) + 1])
print(test_dict)
print(test_dict1)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3ta8jaty41uvvdvpdsf7.png)