teleren/devto huggingface dataset:
Get a free spacial Holopin badge
Tags: holopin, programming, githubhack23, beginners
Published: 2023-11-17 04:28:37

## Contribute to programming-starters-project and Earn the Holopin Badge 🌟

Hey Dev community! 👋 We're thrilled to invite you to contribute to [programming-starters-project](https://github.com/Chhunneng/programming-starters-project), an exciting project that contains a curated collection of beginner-friendly projects in various programming languages and frameworks. Explore, learn, and code your way through hands-on projects to build your skills.

## How to Contribute?

1. **Star the Repository**: Show your support by starring the repository. It helps us reach a broader audience and lets others know that this project is appreciated by the community.
   [Star the Repository](https://github.com/Chhunneng/programming-starters-project)

2. **Fork the Repository**: Fork a copy of the repository to your GitHub account. This way, you'll have your own copy to work on.
    [Fork the Repository](https://github.com/Chhunneng/programming-starters-project)
3. **Clone the Repository**: Clone the repository to your local machine. Use the following command in your terminal:```bash
   git clone https://github.com/Chhunneng/programming-starters-project
```
4. **Create a Branch**:```bash
   git checkout -b feature/your-feature-name
```
5. **Make Changes**
6. **Commit Changes**:```bash
   git commit -m "Add your descriptive commit message here"
```
7. **Push Changes**:```bash
   git push origin feature/your-feature-name
```
8. **Create a Pull Request**:
    [Create a Pull Request](https://github.com/Chhunneng/programming-starters-project/compare) and Put your email in description on pull request to get holopin.

## [Holopin Badge](https://www.holopin.io/sticker/clozb3vv717860fjtjd0ellcc)
![Holopin Badge](https://assets.holopin.io/eyJidWNrZXQiOiJob2xvcGluLWFzc2V0cyIsImtleSI6ImFzc2V0cy9jbG96YnEwc2k2NTI2MGZsOTNyZ3g2NnlpIiwiZWRpdHMiOnsicm90YXRlIjpudWxsfX0=)

Let's Build Something Amazing Together!
If you have any questions or need assistance, feel free to reach out in the comments.

Happy coding! 🚀
React pokedex - FavouritesModal
Published: 2023-11-17 03:30:26

Welcome back! From the previous post we are going to be discussing the FavouritesModal and how it differs from the PokemonModal when in reality they look indentical.

## The problem
As was previously mentioned, I couldn't simply use the same component in the same way as this page was fetching the data from the json server rather than the API.

Now I'm sure there's a way to incorporate both so that you are saving just the pokemon's name in the backend and then you can fetch the relevant data from the API, however I couldn't figure that out and I was pulling out my hair at the best of times.

So to get around that, all of the data that was being rendered on the modal I decided to pass to the json server so that we could simply get that data and render it on a new component.

## The code
Here is the code for the FavouritesModal.jsx

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6a3j314wlzfkwdu9ubtl.png)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4i4jtvb267kkbungtl24.png)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fibldugyqeup31cgczgm.png)

How it works:

- Import statements
- Functional component declaration for pokemon, closeModal function, favourites and updateFavourites
- Type color mapping that maps pokemon types to specific colours
- Set default background colour to gray again if a type can’t be identified
- useState hook to create a piece of state (isInFavourites) and a function (setIsInFavourites) to manage whether the current Pokemon is in the user's favourites
- useEffect hook checks whether the current Pokemon is in the user's favorites and updates the state accordingly whenever the favourites array or the pokemon.id changes
- handleFavourites function is responsible for handling the addition or removal of a Pokemon from the user's favorites. It uses the fetch function to communicate with a server. If the Pokemon is already in the favorites, it removes it; otherwise, it adds it
- JSX structure for the modal component
- Export statement

## Closing remarks
So that's the favourites modal for ya. Again I'm sure there's a more efficient way to do this so that you don't need a separate component but I found this method the easiest for myself!
Ghaziz LLC: Redefining Digital Excellence in Marketing Solutions
Published: 2023-11-17 04:13:45

Elevate your brand with [Ghaziz LLC](https://vocal.media/authors/ghaziz-llc), the trailblazer in digital marketing. Harness the power of innovative campaigns, data-driven insights, and a relentless commitment to your success. Join forces with Ghaziz LLC to amplify your digital footprint and stay ahead in the ever-evolving online landscape.
disable Module model in index admin panel Django
Tags: django
Published: 2023-11-17 04:03:07

tentu django sangat power full untuk pengelolan data dengan query yang mudah,saya akan menshare fitur yang baru ketemu terkait disable module di index panel admin, dimana saya membutuhkan tapi tidak ingin ada di dalam index panel , berikut code yang saya temukan :




![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xbs6bleew28v3aevvh8b.png)
The react pokedex pages
Published: 2023-11-17 03:45:11

For a final post I feel like I should discuss the pages themselves and how they render the way they do. 

## Pokedex page

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

How it works:
- Import statements
- Functional component declaration for Pokedex component
- State hooks to create and manage state variables (when a component needs to “remember” some information between renders) within the pokedex component
- getAllPokemons function is responsible for fetching data about Pokemon from the PokeAPI. It updates the state with the fetched data and the URL for the next set of Pokemon.
- Modal interaction functions to make it visible/hidden
- useEffect hook is used here to run the getAllPokemons function when the component mounts (due to the empty dependency array []). This ensures that the initial set of Pokemon is fetched when the component is first rendered.
- JSX structure that defines how the component is rendered
- Export statement

## Favourites page
Again the favourites page functions a little differently as it is fetching data from the json server rather than the API. Here is the code breakdown of the page:

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

How it works:
- Import statements
- Functional component declaration for the Favourites component
- The useState hooks create and manage state variables within the Favourites component. State allows the component to keep track of data that may change over time.
- The useEffect hook is used here to run the fetchFavourites function when the component mounts (due to the empty dependency array []). This ensures that the list of favorite Pokemon is fetched when the component is first rendered.
- Function to fetch favourite pokemon data - updates the state with the fetched data
- Modal interaction functions - open and close
- Function to update favourite pokemon - passed down to the FavouritesModal component. It updates the state with the latest list of favorite Pokemon after a Pokemon is added or removed.
- JSX structure to render the component
- Export statement

## Final thoughts
So that pretty much sums up the entire project and how I was able to make it. Big thanks to Albert for being an amazing mentor. If you want to check out the app you can access it here: https://p2-app.vercel.app/pokedex
Interactive Phone call
Tags: beginners
Published: 2023-11-17 03:33:52

Hello, everyone.
I have a problem when using Twilio.
I have made a outbounding call with programmable voice.
I have used TwilML to say something to receiver.
And I have also used <Record>tag to record and get transcription from receiver's words.
After recording is ended, I was be able to get transcription but the call is ended also.
I want to call ended when receiver click end call button.
Please help me.
Thanks.
🚀 Exciting Open Source Project: Programming Starters Collection 🌐
Tags: beginners, opensource, programming, tutorial
Published: 2023-11-17 03:15:29

Hey Dev.to community! 👋

I'm thrilled to introduce you to an exciting open-source project that I've been working on – the **Programming Starters Collection**! 🌟

## What is the Programming Starters Collection?

The Programming Starters Collection is a curated repository containing beginner-friendly projects in various programming languages and frameworks. It's designed to help individuals learn and practice coding in a hands-on and practical way.

## 🎯 Project Goals

- Provide a diverse set of projects for different programming languages and frameworks.
- Offer clear and detailed documentation for each project to guide beginners.
- Foster a welcoming and collaborative community for contributors.

## 🌐 Technologies Covered

- Python
- JavaScript (ReactJS included)
- etc.

## How to Contribute?

1. Explore the repository: [Programming Starters Collection](https://github.com/Chhunneng/programming-starters-project)
2. Choose a project that interests you.
3. Follow the provided documentation to implement the project.
4. Open a pull request to contribute your work.

## Example Projects

- Number Guessing Game in Python
- Password Generator in Python
- Random Quote Generator in JavaScript
- Calculator App in ReactJS

## 💻 Why Contribute?

- Sharpen your coding skills with hands-on projects.
- Help beginners learn by providing clear and detailed examples.
- Be part of a growing open-source community.

## How to Get Started?

1. Fork the repository: https://github.com/Chhunneng/programming-starters-project
2. Choose a project folder based on your preferred language or framework.
3. Follow the documentation to complete the project.
4. Submit a pull request and join the community!

## 🌟 Let's Build Together!

I'm excited to invite you to join this collaborative project. Whether you're a seasoned developer or just starting your coding journey, there's a place for you in the Programming Starters Collection.

Explore the repository and start contributing today: [Programming Starters Collection](https://github.com/Chhunneng/programming-starters-project)

Let's build and learn together! 🚀 Feel free to share your thoughts and ideas in the comments.

Happy coding! 🎉

Chrea Chanchhunneng
chreachanchhunneng@gmail.com
Handling Data Updates and Expirations in Redis for Enhanced Cache Management
Tags: javascript, node, redis, caching
Published: 2023-11-17 03:03:22

## Handling Data Updates and Expirations in Redis for Enhanced Cache Management

Welcome back to our Redis and Express optimization series! In our previous tutorials, we explored setting up Redis, basic operations like adding and retrieving data, and optimizing data retrieval using Redis caching. Now, let's delve into a crucial aspect of cache management—handling data updates and expirations.

---

## The Challenge of Data Updates:
In a dynamic application, data is constantly evolving. Consider a scenario where a user edits their post. In your database, the post gets updated to reflect the change. However, with our current caching strategy, the outdated post information persists in Redis.

---

## A Quick Recap of Redis Key-Value Storage:
Redis, being a key-value store, retains data in memory. For instance, the key "post1" might be associated with the value "I like cars." But what if a user updates their post to "I don't like cars"? How can we ensure our cache reflects this change?

---

## Strategies for Handling Data Updates:

1. Immediate Update Approach:
  - When a user updates their post, we can immediately update the corresponding Redis cache using client.set. This approach guarantees that our cache is always synchronized with the latest data in the database.

2. Expiration-based Approach:
  - Alternatively, we can set an expiration time for each cache entry. After a specified period (e.g., 10 seconds), Redis automatically clears the cache. Subsequent requests trigger a fresh data retrieval, ensuring updated information is fetched.

---

## Combining Strategies for Robust Cache Management:
The ideal approach often involves a combination of both strategies. Immediate updates ensure consistency in real-time, while expirations act as a safety net, preventing outdated data from persisting indefinitely.

---

## Implementing Expirations in Redis:

Let's explore the expiration approach. When setting a value in Redis, we can specify its time-to-live (TTL) using the EX parameter:

```
// Example: Setting a value with a 10-second expiration
client.setEx('post1', 'I like cars', 'EX', 10);

```
This code ensures that the key "post1" will expire and be removed from the cache after 10 seconds.

---

## Practical Demonstration:
Let's observe this in action. In our example, we set a cache expiration of 10 seconds for a post. After this period, Redis automatically removes the entry, prompting a fresh data retrieval.

---

## Conclusion:
Handling data updates and expirations is crucial for maintaining a reliable and responsive cache system. Whether you opt for immediate updates, expirations, or a blend of both, understanding these strategies ensures your application remains performant and up-to-date.

In our next tutorial, we'll explore more advanced features of Redis, so stay tuned for further Redis and Express optimization insights!
Setting Up Redis and Express for Your Application
Tags: javascript, redis, node, caching
Published: 2023-11-17 03:02:33

## Setting Up Redis and Express for Your Application
Welcome back! In the previous section, we explored the concept of Redis caching and how it can significantly boost query performance. Now, let's dive into the practical side of things and set up Redis on our local machine to get ready for integration with our Express.js application.

---

## Downloading Redis:

1. Visit Redis Official Page:
  - Go to the official [Redis page](https://redis.io/download/).

2. Choose Stable Version:
  - On the Downloads page, select the stable version for your operating system.

3. Download and Extract:
  - Click "Download" to get the Redis archive.
  - Extract the contents to a directory of your choice.

4. Run Redis Server:
  - Navigate to the extracted folder.
  - Enter the "src" directory.
  - Find and execute the "redis-server" executable.

5. Test Connection with Redis CLI:
  - Open another terminal.
  - Navigate to the same directory.
  - Run the "`redis-cli`" executable.
  - Type `ping` to test the connection. You should receive a "pong" response.


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


That's it! You now have Redis up and running on your local machine.

---

## Setting Up Your Express Application:
Now, let's set up an Express.js application to integrate with Redis.

1. Initialize Node Application:
  - Open your preferred text editor (e.g., Visual Studio Code) in an empty directory.
  - Open the integrated terminal.
  - Run `npm init -y` to initialize a Node.js application.

2. Install Express:

Create an `index.js` file.
Install Express using `npm install express`.

```
// index.js
const express = require('express');
const app = express();

const port = 8800;

app.listen(port, () => {
  console.log(`Now listening on port ${port}`);
});

```

3. Install Nodemon (Optional):
  - Install Nodemon globally for automatic server updates.
  - Use `npm install -g nodemon`.

```
nodemon index
```

4. Install Redis Library:
  - Install the redis library for connecting to Redis.
  - Use `npm install redis`.

```
// index.js
const express = require('express');
const redis = require('redis');

const app = express();
const port = 880;

const redisUrl = 'redis://localhost:6379';
const client = redis.createClient(redisUrl);

app.use(express.json());

app.listen(port, () => {
  console.log(`Now listening on port ${port}`);
});

```

---

With Redis and Express set up, we are ready to move on to the next section, where we'll explore how to insert data into Redis. Stay tuned for the continuation of this tutorial!
Streamlining Development with GitHub Actions: A CI Adventure
Published: 2023-11-17 03:02:32

## Introduction

Embarking on the journey to set up Continuous Integration (CI) using GitHub Actions has been a game-changer for my project. In this blog post, I'll walk you through the simple steps I took to implement CI, share my experience contributing to a partner's repository, and reflect on the newfound benefits of automated testing.

## Setting Up GitHub Actions CI Workflow

Setting up CI using GitHub Actions was surprisingly straightforward. I created a GitHub Actions workflow by adding a YAML file to my repository. This file outlined the conditions triggering the CI process and the steps to execute. Here's a snippet of what my GitHub Actions CI Workflow YAML looked like:

```yaml
name: CI

on:
  push:
    branches:
      - main

  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: 3.11

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run tests
        run: |
          python -m unittest discover tests
```

This workflow is triggered on any push to the main branch or any pull request to the main branch. It uses the latest version of Ubuntu, sets up the Python environment, installs project dependencies, and runs the unit tests.

## Writing Tests for a Partner's Repository

Contributing to a partner's repository introduced me to a different coding environment. Despite the differences, the collaboration was smooth. I identified areas for additional test coverage, wrote tests, and collaborated with my partner to ensure alignment with the project's objectives.

Writing tests for someone else's code enhanced my understanding of diverse coding practices and strengthened my adaptability. Communication played a crucial role in navigating the nuances of unfamiliar codebases.

Link to the PR - [PR28](https://github.com/mnajibi/tml/pull/28)

## Reflections on Continuous Integration

Implementing CI has simplified my development process. Automated tests run effortlessly on every push or pull request, providing quick feedback on the project's health. CI has become a safety net, catching issues before they reach the main branch.

## Conclusion

The journey through setting up CI, contributing to a partner's project, and embracing automated testing has been both educational and empowering. GitHub Actions has seamlessly integrated into my workflow, offering a hassle-free solution for continuous testing.

In conclusion, the simplicity of GitHub Actions makes CI accessible to developers at any level. The experience has not only improved the reliability of my projects but has also opened doors to collaborative development and best practices in software testing.
Understanding Caching with Redis: A Step-by-Step Tutorial
Tags: node, typescript, javascript, redis
Published: 2023-11-17 03:02:01

## Introduction:
Welcome back, everyone! In this tutorial blog post, we'll dive into the concept of caching and explore how Redis, an open-source in-memory data structure store, can significantly speed up query times from our server.

---

## What is Redis?
On the RedisToGo landing page, Redis is described as an in-memory data structure store primarily used as a database cache. But what does "in-memory" mean, and why would we want to use it? Let's break it down.

---

## In-Memory Data Store:
Traditional databases like PostgreSQL and MongoDB store data persistently on disk. In contrast, an in-memory data store keeps data in volatile memory. If the system running the database goes down, the data is lost. So, why use in-memory databases?

---

## Caching and Query Optimization:
The primary reason is caching. Imagine a scenario where our server needs to retrieve a specific post from a database with millions or billions of records. Without optimization, the database would perform a full-body scan, searching through each record until it finds the requested one. This process can be slow and resource-intensive.

---

## Introducing Redis as a Solution:
To address this, we introduce Redis, an in-memory key-value store. Unlike traditional databases, Redis can immediately retrieve data associated with a specific key, offering a significant performance boost.

---

## How Redis Caching Works:
We visualize the process with a server-database model. Traditionally, the server queries the database for data. With Redis, before going to the database, the server checks with Redis if it already has the required data. If Redis has the data (cached), the server retrieves it from Redis, skipping the potentially expensive database query.

---

## Real-World Scenario:
Consider a scenario where our application frequently requests post data with an ID. Redis allows us to cache this data, reducing the need for repeated, time-consuming database queries.

---

## Implementing Redis Caching:
In the next sections, we'll delve into a real-world example using Node.js as our server. However, note that Redis is versatile and works with various servers and languages. We'll cover the code implementation and explore how to leverage Redis to optimize query performance.

---

## Conclusion:

Caching with Redis is a powerful technique for enhancing the speed and efficiency of data retrieval in applications with high query volumes. Stay tuned for the upcoming sections where we'll practically implement Redis caching in a Node.js environment.

Stay connected for the next section, where we'll guide you through downloading Redis on your local machine. Redis is a valuable tool in your development arsenal, regardless of the server or language you're working with. See you in the next section!
Doramasmp4
Published: 2023-11-17 02:57:01

Ver online [doramasmp4](https://doramasmp4.sr/) coreanas, chinos, Tailandia, Japones, Estrenos Doramas con subtítulos en español gratis.
https://in.pinterest.com/doramasmp4sr/
https://issuu.com/doramasmp4.sr
https://www.behance.net/doramasmp414
https://blogs.ubc.ca/etec540socialmedia2013/references/#comment-80995
https://blogs.bu.edu/hogan/?p=14&cpage=22#comment-668850
https://sketchfab.com/doramasmp4tv
https://my.archdaily.com/us/@doramasmp4-3
https://list.ly/doramasmp4tv/lists
https://letterboxd.com/doramasmp4co/
https://speakerdeck.com/doramasmp4tv
Aniwatch
Published: 2023-11-17 02:52:20

[Aniwatch](https://aniwatch.su/) is a free anime streaming site where you can watch English Subbed and Dubbed anime for free, without an account and we update daily.
https://in.pinterest.com/aniwatchsu/
https://issuu.com/aniwatch.su
https://www.behance.net/aniwatch2
http://publish.lycos.com/forexfinancial/vitamin-and-mineral-deficiencies-neurotransmitters-and-memory/#comment-134764
https://blogs.ubc.ca/etec540socialmedia2013/references/#comment-80994
https://blogs.bu.edu/hogan/?p=14&cpage=22#comment-668849
https://sketchfab.com/aniwatch
https://my.archdaily.com/us/@aniwatch
https://list.ly/aniwatchtv/lists
https://letterboxd.com/aniwatchtv/
https://speakerdeck.com/aniwatch