teleren/devto huggingface dataset:
The Drupal 10 Development Cookbook is out!
Tags: drupal, php
Published: 2023-02-10 15:06:21

The Drupal 10 Development Cookbook is officially out! Special thanks to [Kevin Quillen](https://kevinquillen.com/im-officially-published-author) for his amazing assistance in writing the book. And my good friend [Justin Cornell](https://www.drupal.org/u/cornifex) as a technical reviewer. You can order the print or ebook on [Amazon](https://amzn.to/3IdvRcT) (affiliate link) or [Packt](https://www.packtpub.com/product/drupal-10-development-cookbook-third-edition/9781803234960)! This is technically the 3rd edition of the book. The first edition came out with the Drupal 8.0 release, and the second was around Drupal 8.5.0. So this covers everything that came with Drupal 9 and was added for Drupal 10!

We have 450 pages and fourteen chapters with walkthroughs and breakdowns for development with Drupal 10.

- Up and Running with Drupal
- Content Building Experience
- Displaying Content through Views
- Extending Drupal with Custom Code
- Creating Custom Pages
- Accessing and working with entities
- Creating Forms with the Form API
- Plug and Play with Plugins
- Creating Custom Entity Types
- Theming and Frontend Development
- Multilingual and Internationalization
- Building APIs with Drupal
- Writing Automated Tests in Drupal
- Migrating External Data into Drupal


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/azyx9zymipwh3bepakwo.jpg)
20. Valid Parentheses - JavaScript Solution - by Abu Saleh Faysal
Published: 2023-02-10 14:54:08

An array of parentheses are given. We need to find out if the array contains both opening and closing parentheses or not.

**Steps**
01. Declare a variable called "stack" and store an empty array.

02. Iterate a for loop over the given array and store the array elements inside a variable called "char".

03. Using switch case, check the elements and in case the individual element is an opening parenthesis, push a closing parentheses in stack array which was declared earlier.

04. If the individual element is not an opening parentheses, take the last element from stack array and store it inside a variable named "topElement".

05. If "topElement" is not equal to "char", return false.

06. After the completed iteration, check the length of "stack" array is zero, if it is zero, return true and if it is not zero, return false.

- Runtime: 86 ms.

- Memory: 42.8 MB.

```
/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
     let stack = [];

     for(let i = 0; i < s.length; i++) {
         let char = s[i];

         switch(char) {
             case "(": stack.push(")");
             break;

             case "{": stack.push("}");
             break;

             case "[": stack.push("]");
             break;

             default: 
             let topElement = stack.pop();
             if(char !== topElement) {
                 return false;
             }
         }

     }
     return stack.length === 0;
};

```
👉 Support me: https://www.buymeacoffee.com/abusalehfaysal
👉 YouTube Channel: https://www.youtube.com/@thebacklogprogrammer
👉 PlayList Link: https://youtube.com/playlist?list=PLUnklBXn8NSefCpBaLe39mds6dQx-tDDD
👉 Connect with me (LinkedIn): https://www.linkedin.com/in/abusalehfaysal
👉 Follow our LinkedIn Page: https://www.linkedin.com/company/thebacklogprogrammer/
👉 Like our Facebook page: https://www.facebook.com/thebacklogprogrammer/
👉 Join our community (Facebook group): https://www.facebook.com/groups/5500588936676942/
👉 Follow me at: https://www.facebook.com/AbuSalehFaysal10
👉 Twitter: https://twitter.com/AbuSalehFaysal
👉 Abu Saleh Faysal’s Blog: https://abusalehfaysal.hashnode.dev/
👉 Hasnode: https://hashnode.com/@AbuSalehFaysal
👉 Dev Community: https://dev.to/abusalehfaysal
👉 freeCodeCamp: https://www.freecodecamp.org/abusalehfaysal
👉 Medium: https://abusalehfaysal.medium.com/
👉 GitHub: https://github.com/AbuSalehFaysal
👉 GitLab: https://gitlab.com/AbuSalehFaysal
The only markdown cheatsheet you will need
Tags: webdev, beginners, javascript, programming
Published: 2023-02-10 14:51:30

Markdown is a lightweight markup language that is widely used for formatting and styling text. It is simple to learn and easy to use, making it a popular choice for creating content for the web. Whether you are a blogger, a content creator, or just someone who wants to format text quickly, Markdown is an excellent choice. In this blog post, we will provide you with the only Markdown cheatsheet you will ever need.

## Headings

Headings are used to organize and structure text. Markdown supports six levels of headings, from H1 to H6.

```md
# H1 (Largest)
## H2
### H3
#### H4
##### H5
###### H6 (Smallest)
```

## Emphasis

To add emphasis to your text, you can use bold, italic, or strikethrough formatting.

```markdown
**bold**
*italic*
~~strikethrough~~
```

## Lists

Markdown supports both ordered and unordered lists. To create an ordered list, use numbers, and to create an unordered list, use asterisks, pluses, or hyphens.

```mdx
## Ordered List
1. Item 1
2. Item 2
3. Item 3

## Unordered List
- Item 1
- Item 2
- Item 3
```

## Links

Links allow you to include hyperlinks in your text. To create a link, use the following syntax:

```markdown
[Link text](URL)
```

## Images

Markdown also supports the inclusion of images. To add an image, use the following syntax:

```markdown
![Image Alt](URL)
```

## Code Blocks

If you need to include code in your text, Markdown supports code blocks and inline code. To create a code block, use three backticks (\`) before and after your code. To create inline code, use a single backtick (\`) before and after your code.

```javascript
# SingleLine Code
 `console.log("Follow me")`

# Multiline Code
    ```
    function printer(text) {
	    console.log(text);
    }
    
    printer("AcidOP on top")
    ```
```


## Blockquotes

To create a blockquote, use the greater than symbol (>) before your text.

```markdown
> Quote here
```

## Horizontal Rules

To create a horizontal rule, use three hyphens (---), asterisks (***), or underscores (___).

```markdown
---
# Or
***
# Or
___
```

## Tables

Markdown also supports the creation of tables. To create a table, use the following syntax:

```markdown
| Column 1 | Column 2 | Column 3 |
| --- | --- | --- |
| Row 1, Column 1 | Row 1, Column 2 | Row 1, Column 3 |
| Row 2, Column 1 | Row 2, Column 2 | Row 2, Column 3 |
```

## Conclusion

That's it! With this Markdown cheatsheet, you now have all the tools you need to format and style your text. Whether you're writing a blog post, a readme file, or just taking notes, Markdown is a great choice. Start using it today and see how much easier it makes your life!

* Fun Fact: This markdown tutorial blog was written using markdown

### Read more of my blogs at [acidop.codes](https://acidop.codes/blogs)
Video: Fast and accurate language identification with Hugging Face and Intel OpenVINO
Tags: nlp, deeplearning, transformers, huggingface
Published: 2023-02-23 16:41:38

---
title: Video: Fast and accurate language identification with Hugging Face and Intel OpenVINO
published: true
date: 2023-02-10 14:42:31 UTC
tags: nlp,deeplearning,transformers,huggingface
canonical_url: https://julsimon.medium.com/video-fast-and-accurate-language-identification-with-hugging-face-and-intel-openvino-9a51045be11e
---

Hyperproductive ML with Hugging Face in action! With just a few lines of code, here’s how I trained a highly accurate language identification model, and then optimized its latency 3x with Optimum Intel and Openvino 😎

{% youtube uUjcMWKSJtk %}
Paracetamol.ts💊| #09: Explica este código TypeScript
Tags: typescript, webdev, spanish, programming
Published: 2023-02-10 14:31:36

## **<center>Explica este código TypeScript</center>**
#### <center>**Dificultad:** <mark>Básico</mark> </center>


```ts
let addThreeNumbers = (x: number, y: number, z: number): number => x + y + z;
console.log(addThreeNumbers(10, 20))
console.log(addThreeNumbers(10, 20, 30, 40))
```

- A. `30`, `100`
- B. `30`, `60`
- C. `NaN`, `60`
- D. `undefined`, `60`

Respuesta en el primer comentario.

---
Get more views on linkedin
Published: 2023-02-10 14:29:31

there is one simple trick to get more views on linkedin,


your headline. It is your first impression for users.

if your post shows on feed, it is what will make people wanna visit your profile 

we fine tuned GPT-3 Model to create awesome catchy headlines.

try it out at https://linkedinheadlinegenerator.com/
How to format SD Card to APFS on Mac
Tags: macos, filesystem, sdcard
Published: 2023-02-10 08:01:21

When I tried to format a SD card to APFS, the newer MacOS disk format, using the disk utility, I received the following error:

```
A GUID Partition Table (GPT) partitioning scheme is required.

```

Apparently, the default format (ExFAT) on the SD Card does not have a partition, and it requires a command line to fix it.

Open the terminal, and type:

`diskutil partitionDisk disk6 GPT APFSX SDDRIVE 0`

Note: replace `disk6` with the actual disk id, and `SDDRIVE` is the name you use for your drive.

This will create the proper partition.

This is the available file systems. Type `diskutil listFilesystems` to view it on your terminal:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/s7tle2dtgn683gwoi2hz.png)
Mastering the Basics: Manipulating the DOM with JavaScript
Published: 2023-02-10 14:28:13

The Document Object Model (DOM) is a programming interface for HTML and XML documents that allows developers to manipulate web pages dynamically with JavaScript. By representing an HTML document as a tree structure, the DOM provides a convenient way to traverse, select, and modify elements on the page. In this article, we will cover the basics of how to manipulate the DOM with JavaScript.

To start, you need to select an element in the DOM. This is done using methods like getElementById, querySelector, or querySelectorAll. Once you have a reference to an element, you can change its properties, such as its style or content, using the properties provided by the DOM API. For example, to change the background color of an element with an ID of element, you would use the following code:


> Javascript
```
> document.getElementById("element").style.backgroundColor = "red";
```

You can also add, remove, or move elements in the DOM using JavaScript. For example, to add a new p element to the end of a div element, you would use the following code:


> Javascript
```
let div = document.getElementById("container");
let p = document.createElement("p");
p.innerHTML = "Hello World";
div.appendChild(p);
```

To remove an element, you can use the removeChild method. For example, to remove the newly created p element, you would use the following code:


>  css

```
div.removeChild(p);
```

If you need to move an element from one location to another, you can use the insertBefore method. For example, to move the p element to the beginning of the div element, you would use the following code:


> css

```
div.insertBefore(p, div.firstChild);
```
In addition to these basic manipulation methods, the DOM provides several events that allow you to respond to user interactions, such as clicks, hovers, and form submissions. You can attach event listeners to elements using the addEventListener method. For example, to run a function when a button is clicked, you would use the following code:


> javascript

```
let button = document.getElementById("button");
button.addEventListener("click", function() {
  alert("Button clicked!");
});
```
It's worth noting that not all browsers implement the DOM API in exactly the same way, so it's important to test your code in multiple browsers to ensure compatibility. Additionally, the DOM API can be slow and inefficient for large or complex documents, so it's important to optimize your code and use tools like the Chrome DevTools to identify performance bottlenecks.

In conclusion, the DOM provides a powerful and flexible way to manipulate web pages with JavaScript. By selecting elements, changing their properties, adding and removing elements, and responding to user interactions, you can create rich, interactive web applications. Whether you're building a simple website or a complex web application, understanding the DOM is an essential part of web development.
An Introduction to Solidity Smart Contract Development
Tags: web3, webdev, programming
Published: 2023-02-10 14:16:00

Smart contracts have been gaining popularity as a means to automate processes, reduce trust issues, and provide security and transparency in various industries. In the world of decentralized applications, smart contracts play a crucial role in executing the terms and conditions agreed upon by parties involved in a transaction. One of the most widely used smart contract development languages is Solidity.

## What are Smart Contracts?

A smart contract is a computer program that automatically executes the terms of a contract when certain conditions are met. It operates on a decentralized platform, removing the need for intermediaries and providing a secure and transparent way to enforce the terms of a contract.

## Solidity Language Basics
Solidity is a high-level programming language designed for writing smart contracts on the Ethereum platform. It is influenced by C++, Python, and JavaScript and supports inheritance, libraries, and user-defined types. In Solidity, you can define variables, functions, and events and implement various control structures such as if-else statements and for loops.

## Creating a Simple Smart Contract:
To give you a sense of how Solidity works, let's create a simple smart contract for a voting system. This contract will keep track of the total number of votes cast, allow voters to cast their vote, and provide a function to retrieve the vote count. Here's an example of how the code for this contract might look:

```
pragma solidity ^0.8.0;

contract Voting {
    uint8 public voteCount;
    mapping(address => bool) public voters;
    
    function vote() public {
        require(!voters[msg.sender], "You have already voted.");
        voters[msg.sender] = true;
        voteCount++;
    }
    
    function getVoteCount() public view returns (uint8) {
        return voteCount;
    }
}


```

Deploying and Testing Smart Contracts

Once you've written your smart contract, you need to deploy it to the Ethereum network. This can be done using a variety of tools such as Remix, Ganache, or Truffle. After deployment, you can interact with the contract by calling its functions and testing its behavior.

**Best Practices in Solidity Development**

- Keep the code simple and well-organized
- Use the latest version of the Solidity compiler
- Test the contract thoroughly before deployment
- Consider security when writing the contract
- Use libraries whenever possible
- Document the code to ensure it is understandable by others

**Conclusion**
In conclusion, Solidity is a powerful tool for developing smart contracts on the Ethereum platform. By following best practices and being mindful of security concerns, you can create secure and transparent applications that automate business processes and reduce trust issues. Whether you're new to **[smart contract development](https://www.appdupe.com/smart-contract-development)** or a seasoned pro, Solidity provides a solid foundation for building decentralized applications.
CVE-2023-22501 - Broken Authentication vulnerability in Jira Service Management
Tags: atlassian, security, iaac, jiraservicemanagement
Published: 2023-02-10 14:12:23

_Written by Fabian Duft_

**Managed Services fixes security vulnerabilities before you even realize they exist**

On February 1st at 7pm Berlin time, Atlassian released the information that a new security vulnerability ([CVE-2023-22501](https://confluence.atlassian.com/jira/jira-service-management-server-and-data-center-advisory-cve-2023-22501-1188786458.html)) with the [highest severity ranking](https://www.atlassian.com/trust/security/security-severity-levels) (critical) was affecting multiple versions of Jira Service Management (Server & Data Center) starting with version 5.3.

This authentication vulnerability would allow attackers in certain cases to impersonate other users and gain access to signup tokens and access to the instance.

With the announcement of the vulnerability, Atlassian also released new patch versions that prevent the exploitation of this security issue.

Due to the severity of the vulnerability, our team prioritized the rollout of the fixed versions and started working on the issue immediately. Due to the usage of IaaC, VCS and collaboration tools, we could identify the affected customers in a few minutes. At the same time, the new patch versions were built and rolled out to all affected customers.

55 minutes after the release of the security vulnerability by Atlassian, all affected customers were identified, patched and informed.
We fixed the critical security vulnerability before any of our customers even knew that the vulnerability existed.

Exactly this QoS is what our customers appreciate about our [Fully Managed Hosting](https://hosting.kreuzwerker.de/en/hosting) because one part of it is continuously keeping our customer systems protected.

If you were not able to patch your systems in time or apply relevant mitigations, we are here to help you.

[Unfortunately it is not possible to find out if your instance has been compromised.](https://confluence.atlassian.com/kb/faq-for-cve-2023-22501-1189797488.html#:~:text=Can%20we%20determine%20if%20Jira%20Service%20Management%20has%20already%20been%20compromised%3F) With the following query however you can check which users might have been affected due to a password reset:

```sql
SELECT CWD_USER.*
FROM CWD_USER_ATTRIBUTES
  JOIN CWD_USER ON CWD_USER.ID = CWD_USER_ATTRIBUTES.USER_ID
WHERE (USER_ID in
  (SELECT USER_ID
  FROM cwd_user_attributes
  WHERE attribute_name='password.reset.after.vulnerable.install'))
```

If you are interested in the Fully Managed Hosting and want to continuously stay protected, just contact us.
Learn Nuxt 3 — Full course for beginners [3 hours] 2023
Tags: javascript, beginners, webdev, tutorial
Published: 2023-02-10 14:08:18


{% embed https://www.youtube.com/watch?v=ww94Jvi8JJo %}

Hello devs,

As a software developer and enthusiast, I am thrilled to announce the release of my new course on Nuxt.js version 3. This course is designed to help developers like myself who are looking to build fast, efficient and scalable applications using the latest version of the Nuxt.js framework.

In this 3 hour course, I will be covering all the core concepts of Nuxt.js, starting from the basics and working our way up to more advanced topics. I will be demonstrating how to use Nuxt.js to build a range of applications, from simple single-page apps to complex, multi-page applications.

The course is packed with hands-on exercises, real-world examples and practical tips, so that you can apply what you learn to your own projects. Whether you are an experienced developer looking to enhance your skills or a beginner just starting out with Nuxt.js, this course is perfect for you.

With the release of Nuxt.js version 3, there has never been a better time to get started with this powerful framework. I am confident that this course will provide you with all the knowledge and skills you need to build amazing applications using Nuxt.js.

So why wait? Sign up for the course today and take your Nuxt.js skills to the next level!

What is Nuxt 3?

Nuxt.js is a JavaScript framework for building user interfaces, particularly for creating single-page applications and progressive web applications. Nuxt.js version 3 is the latest version of the framework, which provides a modular structure for building applications with Vue.js, a popular JavaScript library for building user interfaces. It offers a suite of features such as server-side rendering, automatic code splitting, and optimized performance, making it a good choice for building performant and scalable applications. Additionally, it includes a strong set of default configurations and tools, allowing developers to quickly get started with their projects, while also offering the flexibility to customize their applications as needed.

Guillaume Duhan
Mashroom Server 2.3 released
Tags: microfrontends, typescript, mashroom
Published: 2023-02-10 14:06:37

We've released Version 2.3 of the Microfrontend Integration Platform **Mashroom Server** today.
It comes now with improved TypeScript support and a lot of other neat features. 
Checkout the full post: https://medium.com/mashroom-server/mashroom-server-2-3-released-889c9a519ce4
Prepare-se para o futuro: Oportunidades na Inteligência Artificial para programadores e como aprimorar suas habilidades
Published: 2023-02-10 13:37:18

Vivemos em uma época incrivelmente emocionante de inovação tecnológica e a Inteligência Artificial (IA) é sem dúvida uma das áreas mais fascinantes e dinâmicas. O futuro da IA é extremamente promissor e os programadores têm uma grande oportunidade de contribuir para o seu desenvolvimento e evolução.

A IA está se tornando cada vez mais prevalente em nossas vidas, desde a assistência virtual em nossos smartphones até sistemas avançados de diagnóstico médico. Isso significa que existem muitas oportunidades para os programadores de IA para fazer uma diferença real no mundo e ajudar a solucionar problemas complexos.

Além disso, a demanda por profissionais de IA altamente capacitados só está aumentando e não há sinais de que vá desacelerar. Portanto, se você é um programador interessado em se aprofundar em IA, agora é o momento perfeito para começar a se especializar nesta área.

Para se preparar para o futuro da IA, é importante estar sempre atualizado com as últimas tendências e tecnologias. Isso pode ser alcançado através de cursos de formação contínua e especialização em IA. Existem muitos [cursos online](https://certificadocursosonline.com/) de alta qualidade disponíveis, desde cursos básicos até programas avançados de pós-graduação. Além disso, é uma boa ideia participar de conferências e eventos relacionados à IA para manter-se conectado com a comunidade e aprender sobre as últimas inovações.

Em resumo, o futuro da IA é brilhante e os programadores têm a oportunidade única de contribuir para sua evolução e ajudar a solucionar problemas importantes. Mantenha-se atualizado com as últimas tendências e tecnologias através de cursos de formação contínua e participação em eventos e conferências relacionados à IA. O futuro da IA é agora e a oportunidade para fazer a diferença nunca foi tão grande.