teleren/devto huggingface dataset:
What are Internal Links in SEO?
Published: 2023-01-21 12:50:34

Internal links, as used in SEO, are web links that lead to pages on the same website. In addition to facilitating user navigation, these links also aid search engines in deciphering the organisation and hierarchy of the website's content. Additionally, they can be used to distribute link equity across a website, which will benefit the linked-to pages' search engine rankings.

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

Why is the importance of an internal link to SEO?
Enhancing website design implies improving the site. It is crucial if internal relationships can be seen from the variable of web optimization. By creating joins, you can improve the positioning of your page.

discussing Googlebot! He also enjoys such websites that make use of internal linking. Googlebot knows our page by slithering it well and helps Googlebot with the page's ordering in light of the internal connection.
Internal links are significant for SEO for a number of reasons:

Internal links make it easier for visitors to browse a website and find the information they're looking for.
Internal links aid search engines in comprehending the hierarchy and structure of a website's content, which can have an effect on search engine rankings.
Internal links can help spread link equity throughout a website, which may boost the linked-to pages' search engine rankings.
Internal links can also assist search engines in finding new content on a website.
Relevance: Internal linking can help search engines comprehend the connections and relationships between the various web pages on your website.
Overall, internal links are a crucial component of the architecture of a website, and it's critical to use them wisely to maximize the SEO advantages they can offer.


For more click on the given link at digitalhubdot.com [](https://digitalhubdot.com/what-are-internal-links-in-seo/)
Guide to crack GSOC(Google summer of code).
Tags: gsoc, opensource, programming, computerscience
Published: 2023-01-21 12:25:19

Google Summer of Code (GSOC) is a highly competitive program that provides students with the opportunity to work on open-source projects during the summer. To crack GSoC, it's important to have a solid understanding of the technology and programming languages that are relevant to the project you're applying for, as well as a strong portfolio of related work.

Here are a few resources that can help you to crack GSoC:

The GSoC website: The official website provides detailed information about the program, including the application process, timelines, and frequently asked questions.

GSoC organization's website: The website of the organization you are applying to will have more specific information about the project you are applying for and their requirement.

Open-source community: Participating in open-source communities is a great way to gain experience and to learn about different projects and technologies. Participating in the community will give you the opportunity to work on real-world projects and to learn from experienced developers.

Study material: There are many resources available online to help you learn about different technologies and programming languages, such as tutorials, documentation, and online courses.

Mentors: Reach out to the mentors of the organization and ask for guidance. They may be able to provide you with valuable advice and resources to help you prepare for GSoC.

Ultimately, cracking GSoC requires a combination of technical skills, passion for open-source, and good communication skills. By utilizing these resources and putting in the time and effort to learn and practice, you can increase your chances of success in the program.
Using coding pattern for dsa.
Tags: dsa, leetcode
Published: 2023-01-21 12:19:49

Using coding patterns to crack coding interviews is a powerful strategy that can help you to stand out from other candidates. Coding patterns are common solutions to common problems, and they can be used to solve a wide variety of coding challenges. By understanding and mastering these patterns, you can improve your chances of success in technical interviews.

One effective way to use coding patterns in interviews is to practice solving problems that are similar to the types of questions that are commonly asked in interviews. This will help you to become more familiar with the patterns and to understand how to apply them in different situations. Leetcode is a great resource for this, as it offers a wide variety of problems that are similar to those found in technical interviews.

Another important aspect of using coding patterns in interviews is to understand the trade-offs and limitations of each pattern. This will help you to make informed decisions about which pattern to use in a given situation and how to optimize your solution.

It's also important to understand how to communicate your thought process and solution clearly to the interviewer. This is crucial as it will showcase your understanding of the problem and your ability to think through the problem and explain it well.

In conclusion, using coding patterns to crack coding interviews is a powerful strategy that can help you to stand out from other candidates. By practicing similar problems, understanding trade-offs and limitations of each pattern, and clearly communicating your thought process, you can improve your chances of success in technical interviews.
Guide for using Leetcode.
Published: 2023-01-21 12:17:28

Leetcode is a popular platform for preparing for technical interviews and improving your coding skills. It offers a wide variety of problems, ranging from easy to hard, and in different categories such as algorithms, data structures, and databases. To use Leetcode effectively, it's important to have a solid understanding of the coding patterns that are commonly used in the problems.

One effective way to use Leetcode is to start with easy problems and gradually increase the difficulty level. This will help you to build a strong foundation in the basics of algorithms and data structures. It's also a good idea to focus on one category at a time, such as sorting and searching, before moving on to the next.

Another important aspect of using Leetcode effectively is to practice solving problems in different programming languages. This will not only help you to become more proficient in different languages, but it will also help you to understand how to approach problems in different ways.

Once you have a good understanding of the basics, it's time to tackle the harder problems. These problems will often require you to think outside of the box and come up with new and innovative solutions. It's important to take your time and think through the problem carefully before jumping into the solution.

Another way to increase your coding skill is to practice solving problems in a timed setting. This will help you to improve your speed and efficiency, which are important skills for technical interviews.

Lastly, it's important to review your solutions and look for ways to improve them. This will help you to understand the problem better and to learn from your mistakes.

In conclusion, using Leetcode effectively requires a combination of practice, focus, and perseverance. By starting with easy problems, focusing on one category at a time, practicing in different languages, tackling harder problems, and reviewing your solutions, you can improve your coding skills and increase your chances of success in technical interviews.
Practice Data Structure and Algorithm effectively.
Tags: dsa, algorithms, leetcode
Published: 2023-01-21 12:13:21

Data structures and algorithms are crucial concepts in computer science, and mastering them is essential for any software developer. However, it can be challenging to know where to start and how to practice effectively. In this blog post, we will discuss some tips on how to practice data structures and algorithms to become proficient in them.

## Start with the basics
Before diving into advanced data structures and algorithms, it is essential to understand the basics. This includes understanding the different types of data structures, such as arrays, linked lists, stacks, queues, and trees. It also includes understanding the basic algorithms, such as sorting and searching algorithms.

## Use online resources
There are many online resources available that can help you learn and practice data structures and algorithms. Websites like HackerRank, LeetCode, and CodeForces offer a wide range of problems that you can solve to improve your skills. These problems range from easy to challenging, so you can start with the easy ones and work your way up.

## Practice coding challenges
Another way to practice data structures and algorithms is to participate in coding challenges. These challenges can be found on websites like CodeForces, TopCoder, and CodeSignal. These challenges are great for testing your skills and getting feedback on your code.

Implement data structures and algorithms from scratch
One of the best ways to practice data structures and algorithms is to implement them from scratch. This will help you understand how they work and how to use them effectively. You can start by implementing basic data structures like linked lists and stacks and then move on to more advanced data structures like trees and graphs.

## Read books and articles
Reading books and articles on data structures and algorithms can also help you improve your skills. There are many books available that cover the basics of data structures and algorithms, as well as more advanced topics. Reading these books can help you understand the concepts better and give you a deeper understanding of the subject.

In conclusion, practicing data structures and algorithms is crucial for any software developer. By starting with the basics, using online resources, participating in coding challenges, implementing data structures and algorithms from scratch, and reading books and articles, you can improve your skills and become proficient in data structures and algorithms. With consistent practice, you can become an expert in these concepts and excel in your career as a software developer
What is pipeline operator in JavaScript?
Tags: javascript, beginners, pipeline, operator
Published: 2023-01-21 11:41:54

The pipe operator (|>) is a proposed addition to the JavaScript language that would allow for a more concise and readable way of chaining function calls. It is inspired by similar operators in functional programming languages such as Elixir and F#.

The idea behind the pipe operator is to take the output of one function and immediately pass it as the input to the next function in the chain. For example, consider the following code that uses the map, filter, and reduce functions to transform an array of numbers:
```javascript
const numbers = [1, 2, 3, 4, 5];
const result = numbers
  .map(n => n * 2)
  .filter(n => n > 4)
  .reduce((acc, n) => acc + n, 0);
console.log(result); // 14
```
With the pipe operator, the same code could be written like this:
```javascript
const numbers = [1, 2, 3, 4, 5];
const result = numbers 
|> n => n * 2 
|> n => n > 4 
|> (acc, n) => acc + n;
console.log(result); // 14
```
In this example, the pipe operator takes the numbers array and passes it as the first argument to the first function **(n => n * 2)**, which returns a new array with each element multiplied by 2. This new array is then passed as the first argument to the second function **(n => n > 4)**, which returns a new array containing only the elements that are greater than 4. Finally, this new array is passed as the first argument to the reduce function, which computes the sum of all elements.

The pipe operator can also be used to chain method calls on an object, by providing the object as the first argument to the function. For example:
```javascript
const obj = {a: 1, b: 2, c: 3};
const result = obj 
|> ({a,b}) => ({a,b}) 
|> ({a,b}) => a + b;
console.log(result); // 3
```
The pipe operator is not a part of the official JavaScript language yet, but it is a popular proposal and has been implemented in several transpilers and libraries, such as the pipeline operator proposal in the babel.js transpiler.

One of the main advantages of the pipe operator is that it can make code more readable by making it clear the flow of data through a chain of functions. Instead of having to read the code from left to right and keep track of intermediate variables, the flow of data can be followed directly from the first function to the last. This can make it easier to understand the purpose of the code and to find and fix bugs.

Additionally, it's also a good practice to use the pipe operator when dealing with functional programming, it makes the code look more elegant and readable as well.

However, not every developer might find the pipe operator useful, it's a matter of personal preference, and it's important to evaluate the readability and maintainability of the codebase, before making a decision to use the pipe operator or not.

More information 👇
{% embed https://www.youtube.com/watch?v=h1FvtIJ6ecE %}

_I hope you found this article helpful. Connect with me on [Dev.to](https://dev.to/nisalk) and [LinkedIn.com](https://www.linkedin.com/in/nisalk) Thank you !_
Upload your existing project to github from your linux machine
Tags: git, github, linux
Published: 2023-01-21 11:35:10

In this guide I am going to upload my existing project from my linux machine's terminal to github.

#Initiate Git

Open terminal and navigate to your project's directory.
```
git init
```

#Configure your username and email
```
git config --global user.name "your_github_username"
git config --global user.email "your_github_email"
git config -l
```

#Create an empty repository on Github
![New Repository](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pj3a9ljznikyracqzgd2.png)

![Creating a repository](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/95fnpsvcrxwgioxdz82z.png)

#Copy the https link of that repository
![HTTPS git url](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hn0sxwjnfbvw7s2mbk0y.png)

#Add remote origin
```
git remote add origin https://github.com/username/repo-name.git
```

#Add all files into stage and commit with commit message
```
git add .
git commit -m "Initial Commit"
```

#Now push to github
```
git push origin master
```

#Generate Access Token
Before entering your password Go to `Settings` > `Developer settings` > `Personal access tokens` > `Tokens (Classic)` > `Generate new token (classic)` > Mark `repo` and add a `note` > Hit `Generate Token` > Copy the Token
![Access token generation](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/56214r89135ib2flpndu.png)


#Paste your token into password
![Github access token](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hcnfd0zxfnk1x21121yu.png)

#Cache the record locally to remember the token:
```
git config --global credential.helper cache
```

#Verify
```
git pull -v
```

Source: [StackOverflow](https://stackoverflow.com/questions/68775869/message-support-for-password-authentication-was-removed-please-use-a-personal)
Laravel creates CRUD with Nested Resources
Tags: opensource, php, laravel, laravelframework
Published: 2023-01-22 15:12:07

---
title: Laravel creates CRUD with Nested Resources
published: true
date: 2023-01-21 11:32:24 UTC
tags: opensource,php,laravel,laravelframework
canonical_url: https://blog.devgenius.io/laravel-creates-crud-with-nested-resources-ac97667609a4
---

[![](https://cdn-images-1.medium.com/max/2600/0*qgb9ZPYGeKx6wN9N)](https://blog.devgenius.io/laravel-creates-crud-with-nested-resources-ac97667609a4?source=rss-17217f29618a------2)

Laravel creates an admin panel from scratch — Part 22

[Continue reading on Dev Genius »](https://blog.devgenius.io/laravel-creates-crud-with-nested-resources-ac97667609a4?source=rss-17217f29618a------2)
Polymorphic react component with vanilla-extract
Tags: css, typescript, react, vanillaextract
Published: 2023-01-23 14:50:58

---
title: Polymorphic react component with vanilla-extract
published: true
date: 2023-01-21 11:24:10 UTC
tags: css, typescript, react, vanillaextract
canonical_url: https://krzysztofzuraw.com/2023/polymorphic-react-component-with-vanilla-extract/
---

I started using [vanilla-extract](https://vanilla-extract.style/) library as foundation to design system at work. All is going well, but I have one problem - I couldn't find a good way to create polymorphic React components. I tried with [React TypeScript Cheatsheet](https://react-typescript-cheatsheet.netlify.app/docs/advanced/patterns_by_usecase/#polymorphic-components-eg-with-as-props), but it didn't work for me. I was looking for a solution for a while and I was recommended (thanks Jonatan) to check out this handy little library called [dessert-box](https://github.com/TheMightyPenguin/dessert-box). What this library is doing? It uses a concept of vanilla-extract [sprinkles](https://vanilla-extract.style/documentation/packages/sprinkles/) and connect them together with polymorphic `Box` component.

Let's say you have this sprinkles defined:

```ts
import { createSprinkles, defineProperties } from "@vanilla-extract/sprinkles";

const colorProperties = defineProperties({
  conditions: {
    lightMode: {},
    darkMode: { "@media": "(prefers-color-scheme: dark)" },
  },
  defaultCondition: "lightMode",
  properties: {
    color: [{ brand: "#00a98f" }],
  },
});

export const sprinkles = createSprinkles(colorProperties);
```

Now you want to pass those as atoms to your `Box` component. You can do it like this:

```tsx
import { createBox } from "@dessert-box/react";

import { sprinkles } from "./sprinkles.css";

export const Box = createBox({ atoms: sprinkles });
```

Now you can use it like this:

```tsx
<Box as="button" color="brand">
  Submit
</Box>
```

And it is all type-safe. You can't pass different `color` than `brand` to the `Box`. Now you can build your own components on top of it and combine them into more complex [molecules](https://atomicdesign.bradfrost.com/chapter-2/). It really helps to write as little custom CSS as possible and instead use typed props to style your components.
JS Object Immutablity
Tags: javascript, webdev, beginners, codenewbie
Published: 2023-01-21 10:11:53

Hello Everyone!

We all know that JavaScript objects are mutable by default. In this post, we'll look into few methods by which we can make objects immutable in JavaScript.

## 1) Object.preventExtensions

Object.preventExtensions() method prevents new properties from being added to an object. 
In simple terms, New properties cannot be added to the object. But you can able to modify or delete the existing properties.

The example below will provide you more insights

![preventExtensions Example](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dbyqdjr0nl2dfajcagez.png)

## 2) Object.seal

Object.seal() method prevents new properties being added and existing properties being removed. seal() method will seal the object. 
In simple terms, New properties cannot be added and existing properties cannot be removed. But modification to the existing properties are allowed.

![seal example](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nbl5scldb7wrvlprjt2t.png)

## 3) Object.freeze

You probably might have heard about this before. Object.freeze() method freezes the entire object. This method makes the object unchangeable. New properties cannot be added. Existing properties cannot be deleted nor be updated.

![freeze example](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jf7j7whqpuh3v7yem0fn.png)

**Long story short**

- _Object.preventExtensions()_ - prevents addition of new properties
- _Object.seal()_ - prevents addition of new properties and deletion of existing properties
- _Object.freeze()_ - prevents addition of new properties. Deletion and modification of existing properties.


Thank you so much if you have read it so far. Please do share your thoughts on this.

If you liked reading this blog, please don't forget to like ❤️, comment 💬 and share 🤩 as your support means a lot to me.

Cheers! 🤙
Bad practice- copying code?
Tags: help, webdev, bootstrap
Published: 2023-01-21 10:48:01

Hello I'm currently diving into Bootstrap and I understand how it works and I think it's incredible.

My question is the documentation for bootstrap gives us examples such as a navbar, would it be bad practice to copy and paste this code to then edit to suit our needs?

Or would you write it out every single time, I'm preferably looking at within the industry would they write it from scratch or use a template?

Thanks
Ben
Gradient Animator AnimationName-1674296757141-774.css
Tags: css, gradientanimator, animation, website
Published: 2023-01-21 10:37:23

how to use the gradient animator please see on the website [bangmatz](https://www.bangmatz.blogspot.com)

```
.css-selector {
    background: linear-gradient(270deg, #3a80b4, #1df3fd, #45fcb7);
    background-size: 600% 600%;
    -webkit-animation: AnimationName 30s ease infinite;
    -moz-animation: AnimationName 30s ease infinite;
    -o-animation: AnimationName 30s ease infinite;
    animation: AnimationName 30s ease infinite;
}
@-webkit-keyframes AnimationName {
    0%{background-position:0% 49%}
    50%{background-position:100% 52%}
    100%{background-position:0% 49%}
}
@-moz-keyframes AnimationName {
    0%{background-position:0% 49%}
    50%{background-position:100% 52%}
    100%{background-position:0% 49%}
}
@-o-keyframes AnimationName {
    0%{background-position:0% 49%}
    50%{background-position:100% 52%}
    100%{background-position:0% 49%}
}
@keyframes AnimationName {
    0%{background-position:0% 49%}
    50%{background-position:100% 52%}
    100%{background-position:0% 49%}
}
```
AWS: Messaging and Integration Services
Tags: aws, sns, sqs, ses
Published: 2023-01-21 10:15:12

## Simple Queue Service (SQS):
**SQS** is a message queuing service that allows you to build loosely coupled systems. Loosely coupled systems are systems that are connected but not dependent on each other. **SQS** allows component-to-component communication using message which are processed in an asynchronous manner.

Apps that are loosely coupled can be allow to send, store, and receive messages through the use of **SQS**. The use of a messaging queue helps to improve performance and scalability. 


## Simple Notification Service (SNS):
**SNS** function is allow you to send emails and text messages from your applications or publish messages and subscribers on your applications receives the messages.
**SNS** works with **CloudWatch** when an alarm's metric threshold is breached to send an email.

## Simple Email Service (SES):
**SES** is an email service that send richly formatted HTML emails from your applications. Unlike **SNS**, **SQS**; **SES** sends messages in form of HTML. This is best use for professional emails or campaign.
**SES** can send richly formatted HTML emails in bulk and have vital insights about the effectiveness of the  campaign or mails.