teleren/devto huggingface dataset:
Arc Shortcuts: Windows
Tags: browser, shortcut, windows
Published: 2024-05-15 06:00:48

Here are some helpful Arc Shortcuts for the Windows version that I've found useful. Feel free to try them out and let me know if there are any others worth adding to the list! :)

| Names                                 | Command                                             |
| ------------------------------------- | --------------------------------------------------- |
| New Tab                               | Ctrl + L                                            |
| Archive Tab                           | Ctrl + W                                            |
| Last Tab                              | Ctrl + Shift  + T                                   |
| Switch Between Tabs                   | Ctrl + Alt + [Up/Down Arrow Keys], Ctrl + [Numbers] |
| Pin/Unpin Tab                         | Ctrl + D                                            |
| Switch Spaces                         | Ctrl + Alt +  [Left/Right Arrow Keys]               |
| Split Tab                             | Ctrl + Shift + =                                    |
| Find text on the page                 | Ctrl + F                                            |
| Find Next Matching Result             | Ctrl + G                                            |
| Find Previous Matching Result         | Ctrl + Shift + G                                    |
| Inspect Elements                      | Ctrl + Shift + I                                    |
| Copy the current page URL             | Ctrl + Shift + C                                    |
| Copy the current page URL as Markdown | Ctrl + Shift + ALT + C                              |
| New Browser Window                    | Ctrl + N                                            |
| History                               | Ctrl + H                                            |
| Clear Today's Tabs                    | Ctrl + Alt + K                                      |
| Edit Current URL                      | Ctrl + L                                            |
| Show/Hide Sidebar                     | Ctrl + S                                            |
Speed up GitHub PR’s review of your React applications
Tags: development, tutorial, github, jest
Published: 2024-05-15 05:55:44

Would you like to speed up PR’s review of React application, when you use Jest snapshot testing?

![Photo by [Makarios Tang](https://unsplash.com/@makariostang?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)](https://raw.githubusercontent.com/jetthoughts/jetthoughts.github.io/master/static/assets/img/blog/speed-up-github-prs-review-of-your-react-applications-development-tutorial/file_0.jpeg)

How much time do we spend on waiting while snap files being rendered? Working with lots of large React components’ .snap files, manually collapsing files over and over gets quite painful. But don’t panic, here is the solution: GitHub uses [Linguist](https://github.com/github/linguist) to compute stats about your files, ignore files that are vendored, and even to suppress files that are generated automatically. So, you can configure it to treat files of your choosing in a certain way.

![A hidden big snapshot file](https://raw.githubusercontent.com/jetthoughts/jetthoughts.github.io/master/static/assets/img/blog/speed-up-github-prs-review-of-your-react-applications-development-tutorial/file_1.png)

In the root of the repository create a .gitattributes file. Then use the linguist-generated attribute to mark or unmark paths that you would like to be ignored for the repository’s language statistics and hidden by default in diffs. For example:

![All files with snap extension won’t be rendered](https://raw.githubusercontent.com/jetthoughts/jetthoughts.github.io/master/static/assets/img/blog/speed-up-github-prs-review-of-your-react-applications-development-tutorial/file_2.png)

Use a .gitattributes file to mark files that match a given “pattern” with the specified attributes. A .gitattributes file uses the same rules for matching as .gitingore files.

**Paul Keen** is an Open Source Contributor and a Chief Technology Officer at [JetThoughts](https://www.jetthoughts.com). Follow him on [LinkedIn](https://www.linkedin.com/in/paul-keen/) or [GitHub](https://github.com/pftg).
>  *If you enjoyed this story, we recommend reading our [latest tech stories](https://jtway.co/latest) and [trending tech stories](https://jtway.co/trending).*
5 Must-Have Gadgets for a Smart Home Makeover
Published: 2024-05-15 04:58:34

In today’s fast-paced world, technology has become an integral part of our daily lives, transforming how we live, work, and interact with our surroundings. From smartphones to smart homes, technological innovations have revolutionized how we experience the world around us. As technology enthusiasts, we are constantly seeking ways with these Must-Have Gadgets to harness the power of innovation to enhance our lives and streamline our daily routines. In this article, we will delve into the Top 5 Must-Have Gadgets, exploring five must-have devices that promise to elevate your living space to new heights of convenience, comfort, and security. Join us on a journey of discovery as we uncover the wonders of smart technology and embark on a quest to transform our homes into futuristic sanctuaries of innovation and possibility.

https://typewritertale.com/5-must-have-gadgets-for-a-smart-home/
Docker
Tags: docker, containers, wsl, linux
Published: 2024-05-15 05:41:56

## Why Docker?

When collaborating on a repository shared by multiple people, Docker enables the team to share a consistent development environment. This ensures that everything runs the same and predictably across all machines. Additionally, Docker can help save resources on CodeSpaces and allows for offline development. VS Code Dev Containers offer a local alternative to GitHub CodeSpaces, providing a seamless development experience.

I recently acquired a Lenovo laptop with Windows. The hardware is an upgrade from my 2013 MacBook Pro, although my MacBook is more portable. With Docker and Windows Subsystem for Linux (WSL), I can work on the same code reliably across different machines, enjoying a Linux environment on Windows.

- It's crucial to create your repositories within WSL rather than on the Windows file system. This improves performance and resolves some bugs. For instance, I discovered that live reloading became possible after storing files in WSL.
  
- You know you're in Windows if the terminal looks like:

```bash
PS C:\Users\user-name>
```

- Open the terminal and run:

```bash
wsl --distribution Ubuntu
```

- Next, your terminal may look something like:

```bash
name@DESKTOP:/mnt/c/Users/name$
```

- Be careful, you are still in the Windows file system. Run `cd` to get back to the home directory. You should see:

```bash
name@DESKTOP:~$
```

- Now you can clone repositories and open them in a Dev Container from within the WSL file system for increased performance. The performance is improved because WSL offers better integration with Docker.
- Alternatively, you can configure the WSL configuration file to open directly to the Linux home directory.

## What is a Container?

Docker containers allow you to run code in a defined, isolated environment. This ensures consistency and reliability, as the environment remains the same regardless of where the container is run.

## Up Next

Next time, we'll cover running a container. We'll create an image using a Dockerfile and a sample application.

## Useful resources

You can download docker here:

https://www.docker.com/

Download the VS Code extensions:

https://code.visualstudio.com/docs/devcontainers/containers

Developing inside a Container:

https://code.visualstudio.com/docs/devcontainers/containers

Try out with different development environments:
 
https://github.com/search?q=org%3Amicrosoft+vscode-remote-try-&type=Repositories

https://github.com/Microsoft/vscode-remote-try-node
Laravel Relationship Recipes: Simplify Querying with hasManyThrough
Tags: php, laravel, webdev, beginners
Published: 2024-05-15 05:30:00

## Laravel Relationship Recipes: Simplify Querying with hasManyThrough

In today's edition of Laravel Relationship Recipes, we'll explore the `hasManyThrough` relationship method, a powerful feature that simplifies querying related models through an intermediate model.

## Understanding the Scenario

Consider a scenario where you have three models: `Department`, `Employee`, and `Paycheck`. Each department has multiple employees, and each employee has multiple paychecks. To retrieve all the paychecks within a department, you can utilize the `hasManyThrough` relationship.

## Introducing the hasManyThrough Method

In your `Department` model, you can define a `paychecks` relationship using `hasManyThrough`:

```php
class Department extends Model
{
    public function employees(): HasMany
    {
        return $this->hasMany(Employee::class);
    }
    
    public function paychecks(): HasManyThrough
    {
        return $this->hasManyThrough(Paycheck::class, Employee::class);
    }
}
```

The `hasManyThrough` method takes two arguments: the related model (`Paycheck` in this case) and the intermediate model (`Employee`). With this relationship in place, you can now easily retrieve all the paychecks within a department.

## Simplifying Querying

Instead of writing complex nested queries, you can now simply use the `paychecks` relationship on the `Department` model:

```php
$department->paychecks;
```

This concise syntax makes querying related models a breeze, improving code readability and maintainability.

## Conclusion

The `hasManyThrough` relationship in Laravel Eloquent provides a convenient way to query related models through an intermediate model. By leveraging this method, you can streamline your code and simplify complex querying scenarios.

Stay tuned for more Laravel Relationship Recipes in this series, where we'll continue to explore useful methods for working with Eloquent relationships!
Vulnerability Assessment and Penetration Testing
Tags: services
Published: 2024-05-15 05:26:43


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

Enhance Your Cybersecurity with Mobisoft Infotech's VAPT Services: Explore Mobisoft Infotech's comprehensive VAPT services aimed at securing your digital infrastructure. Our expert team conducts thorough vulnerability assessments and penetration testing to identify and address potential security weaknesses in your systems. Partner with us to fortify your defenses and safeguard your data against cyber threats.https://mobisoftinfotech.com/services/cybersecurity-services/vapt-services
Making Homemade Pizza with Delicious Tomato Sauce
Tags: sauce
Published: 2024-05-15 05:22:18

How to Make Homemade Pizza with Delicious Tomato Sauce

1. Advantages of developing Homemade Pizza

Who doesn’t appreciate pizza? Did you know that making their homemade pizza has plenty of pros? First, it is additional cost-effective to organize pizza at homes instead of ordering it from a restaurant. You may also salvage time and energy by making your pizza quickly and perfectly. Making homemade pizza enables you to customize the toppings and crust to your taste. The about significant advantage of homemade pizza is that you can make sure the quality and freshness with this ingredients used. Therefore, homemade pizza is a more healthy option than restaurant pizza.

2. Innovation in Homemade Pizza
Do you believe making homemade is boring? Think again. There are lots of innovations you can explore when making your homemade pizza. You'll try innovative pizza using unique and flavorful ingredients, such as bacon, smoked chicken, or goat cheese. Mixing different spices and herbs also can add a distinct flavor your szechuan tomato sauce  For the crust, an individual might experiment by simply which makes it thin, crispy, thick, or stuffed. Using mozzarella, cheddar, if not other kinds concerning cheese can bring excitement to also your homemade pizza.





3. Safety Measures to Make Homemade Pizza
Safety should constantly be best tomato sauce a priority it is top making your homemade pizza. Before preparing the pizza, assure your all utensils, areas, and ingredients are clean and dry. Raw dough or batter can contain unwanted organisms, so ensure it correctly towards prevent illness that you handle. Use mitts when handling meat that's raw and wash your hands thoroughly before and after ones preparation. When cooking pizza each oven, be mindful and use mittens when handling hot objects.





4. Steps to Make Homemade Pizza With Delicious Tomato Sauce
Achieving homemade pizza and delicious Tomato Sauce was easy and fun. First, prepare the Tomato Sauce by blending fresh or canned Tomatoes, garlic, salt, and herbs such as basil or oregano. Upcoming, preheat the range to 450°F and roll the pizza crust out on a floured surface. Add that the desired Tomato Sauce to the crust, spreading it evenly. Add toppings of your choice, such as cheese, meat, and vegetables. Lastly, bake inside ones oven for 10-15 minutes, or until some sort of crust is golden brown.

5. Quality Service and Application
If you’re tired of purchasing pizza from restaurants and would like to try making the homemade pizza, there are numerous quality services and applications available that may help in. For example, there are online baking classes, cooking channels, and internet sites that provide step-by-step recipes, instructions, and approaches for making homemade pizza. Generally there will also be cellphone applications that feature recipes basic tomato sauce, grocery listings, and cooking timers. These types of services and applications will help we improve your pizza-making skills and make delicious homemade quickly and easily.
Klay Hr Consultants - Leading HR Consultancy Firms In Dubai
Tags: hrconsultancyua, recruitmentservicesuae, klayhrconsultants
Published: 2024-05-15 05:16:49

Klay HR Consultants is a leading **[HR consultancy companies in Dubai]**(https://klayhr.com/), offering a powerful combination of HR and legal expertise to tackle complex people-related challenges. With a focus on reducing costs, boosting efficiency, and improving employee relations, Klay HR Consultants aims to be an invaluable partner for businesses, providing peace of mind by navigating the ever-changing landscape of employment laws. Their talent acquisition expertise helps in attracting top performers and crafting engaging onboarding programs, while their strategic HR and legal solutions provide businesses with a cost-effective edge and a thriving, future-proofed environment. With an emphasis on professional HR outsourcing services, Klay HR Consultants allows businesses to focus on core activities and witness exponential growth.
Mastering Cross-Platform App Development with React Native
Published: 2024-05-15 05:00:00

Why React Native?
React Native, developed by Facebook, enables developers to build native mobile apps using only JavaScript and React. It allows you to leverage the same codebase for both iOS and Android platforms, saving time and resources. With React Native, you can create high-quality, performant apps with a single codebase, while still retaining the look and feel of native applications.

Getting Started
To begin your journey with React Native, make sure you have Node.js and npm (Node Package Manager) installed on your machine. You can then install React Native CLI globally by running the following command:

```
npm install -g react-native-cli

```
Once React Native CLI is installed, you can create a new React Native project by running:

```
Replace MyApp with the name of your project. This command sets up a new React Native project with the necessary files and dependencies.

Building Your First Cross-Platform App
Let's create a simple cross-platform app that displays a welcome message. Navigate into your project directory and open App.js in your preferred code editor. Replace the contents of App.js with the following code:
```

```
import React from 'react';
import { Text, View, StyleSheet } from 'react-native';

const App = () => {
  return (
    <View style={styles.container}>
      <Text style={styles.text}>Welcome to React Native!</Text>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#f0f0f0',
  },
  text: {
    fontSize: 20,
    fontWeight: 'bold',
    color: '#333',
  },
});

export default App;

```
This code defines a simple React component that renders a welcome message inside a View component. We use StyleSheet to style our components.

Running Your App
To run your app on an iOS or Android simulator, first, make sure you have Xcode (for iOS) or Android Studio (for Android) installed on your machine. Then, navigate to your project directory and run:

```
npx react-native run-ios

```
Conclusion
In this article, we've only scratched the surface of what React Native can do. With its extensive ecosystem of libraries and tools, React Native provides a powerful solution for building cross-platform mobile applications. Whether you're a seasoned developer or just getting started, React Native offers a flexible and efficient way to create stunning mobile apps with JavaScript.

Start experimenting with React Native today and unlock the full potential of cross-platform app development! Happy coding!

---
Thank you for reading my article! For more updates and useful information, feel free to connect with me on LinkedIn and follow me on Twitter. I look forward to engaging with more like-minded professionals and sharing valuable insights.
JS Hoisting cheatsheet | 2 mins read only
Tags: webdev, javascript, programming, tutorial
Published: 2024-05-15 04:59:55


# JavaScript Hoisting Cheat Sheet

## What is Hoisting?
- **Hoisting** is JavaScript's default behavior of moving declarations to the top of the current scope (script or function).

## Key Points
- Only declarations are hoisted, not initializations.
- Both variable and function declarations are hoisted.
- Function expressions are not hoisted.
- `let` and `const` declarations are hoisted but not initialized.

## Variable Hoisting

### `var` Declarations
- `var` variables are hoisted to the top of their function scope.
- They are initialized with `undefined`.

```javascript
console.log(x); // undefined
var x = 5;
```

### `let` and `const` Declarations
- `let` and `const` variables are hoisted to the top of their block scope.
- They are not initialized; accessing them before initialization results in a `ReferenceError`.

```javascript
console.log(y); // ReferenceError
let y = 10;

console.log(z); // ReferenceError
const z = 15;
```

## Function Hoisting

### Function Declarations
- Function declarations are hoisted to the top of their scope.
- They are fully hoisted, including their definition.

```javascript
hoistedFunction(); // "Hello, World!"

function hoistedFunction() {
    console.log("Hello, World!");
}
```

### Function Expressions
- Function expressions are not hoisted.
- They are treated like variable assignments and are initialized only when the execution reaches that line.

```javascript
nonHoistedFunction(); // TypeError: nonHoistedFunction is not a function

var nonHoistedFunction = function() {
    console.log("Hello, World!");
};
```

## Arrow Functions
- Arrow functions behave like function expressions and are not hoisted.

```javascript
arrowFunction(); // TypeError: arrowFunction is not a function

var arrowFunction = () => {
    console.log("Hello, Arrow!");
};
```

## Class Hoisting
- Classes are hoisted but not initialized.
- Accessing a class before its declaration results in a `ReferenceError`.

```javascript
new MyClass(); // ReferenceError: Cannot access 'MyClass' before initialization

class MyClass {
    constructor() {
        console.log("Class created");
    }
}
```

## Temporal Dead Zone (TDZ)
- The TDZ is the time between entering scope and variable declaration where variables are in an uninitialized state.
- Accessing a variable in the TDZ results in a `ReferenceError`.

```javascript
{
    console.log(a); // ReferenceError: Cannot access 'a' before initialization
    let a = 3;
}
```

## Best Practices
- Declare all variables at the top of their scope to avoid confusion.
- Use `let` and `const` instead of `var` to prevent unexpected behavior.
- Be mindful of the TDZ when using `let` and `const`.
The Ultimate Foodie Tour: Uncovering Culinary Delights Across Southeast Asia
Published: 2024-05-15 04:58:12

Embark on a culinary adventure like no other as we journey through Southeast Asia’s vibrant streets and bustling markets. From the tantalizing aromas of Bangkok’s street food stalls to the rich flavors of Penang’s multicultural cuisine, get ready to uncover a world of culinary delights that will tantalize your taste buds and ignite your sense of adventure. Whether you’re a seasoned foodie or simply curious to explore new flavors, join us as we embark on the ultimate foodie tour across Southeast Asia, where every meal is an opportunity to discover the rich tapestry of cultures that define the region’s vibrant culinary landscape.

Learn More About Us!

https://typewritertale.com/ultimate-foodie-tour-across-southeast-asia/
Firebase Realtime Database vs Cloud Firestore
Tags: firebase, cloud, firestore, realtimedatabase
Published: 2024-05-15 04:57:59

## Introduction
For the last couple of years, I am using **Firebase** extensively in my personal projects. One of the most difficult choice is to make between **Firebase Real-time Database** vs **Cloud Firestore**. After using both of them here are some of the key points I found which can help you to choose between both of the storage options -

## When to use Realtime Database?

- Firebase Realtime Database is great for apps that need data to sync in real time across users and have relatively simple data models. 
- Realtime Database works well for projects on a budget that require high real-time functionality. 
- It's a good fit for small to medium-sized apps where complex queries and scaling aren't major concerns. 

## When to use Cloud Firestore ? 
∙ Cloud Firestore is a better choice for larger apps that need strong data modeling and advanced querying. 
∙ It's perfect for apps with complex, hierarchical data structures that need to be queried in multiple ways. 
∙ Cloud Firestore is suitable for high-performance, scalable apps, especially those with global audiences and extensive data operations. 

## Summary
To sum it up, Firebase Realtime Database is best for simple real-time apps with less complex data or budget considerations. On the other hand, Cloud Firestore is the better option if your app needs advanced querying, more complex data structures, and better scalability. If you like this blog and you want to learn more about Frontend Development and Software Engineering you can follow me on [Dev.to](http://dev.to/debajit13).
8 Software Truths
Tags: programming, software, softwareengineering
Published: 2024-05-15 04:57:50

- A poor abstraction is worse than duplicating code
- Complexity is considerably easier to add than it is to remove
- All code errors are type errors, but not all type systems are expressive enough to surface them
- Given enough time all class hierarchies are eventually wrong for new use cases
- Developers who believe they can foresee the future are more dangerous than missing business requirements
- Meetings are not for communication, they are for making decisions
- Methods that work well with remote teams don't work well with traditional hierarchical management structures
- Code metrics are an effort to abstract developer output into something a manager with no domain experience can understand