teleren/devto huggingface dataset:
Publishing Alpine Linux packages using GitHub actions
Tags: opensource, automation, linux, alpinelinux
Published: 2023-08-17 18:09:57

Not so long ago, I decided to install Alpine Linux on some compact laptops I use when I'm out and about. One of them is an 11" 2015 Macbook Air. I have often installed Linux on Macbooks, but the experience could be more optimal, as there are many issues with the firmware support, as most of the time is closed. Alpine would be an excellent fit for this old Macbook, as the RAM and CPU specs are fundamental, and any other modern OS (macOS or other Linux distribution) would make it slow and unusable.


However, there were two firmware drivers that I couldn't find for this Macbook:

* The wireless network card (broadcom-wl)
* The FaceTime HD webcam (facetimehd)

To make this portable laptop something I could use when I'm not at home and to be able to work and take video calls using Zoom. I needed these two to work. So, [with the deprecation of the non-free aports repository](https://gitlab.alpinelinux.org/alpine/tsc/-/issues/23), I needed to do it from scratch if I wanted to build them. Given that the laptop has limited resources, I didn't want to create the `apk`s on it, so I made them on my main computer and installed the packages from the `.apk` files. This worked, but then I wanted to host the packages somewhere, so I could install them by adding a new repository.


After [searching GitHub](https://github.com/acj/action-abuild), I found an action that builds the packages, but it stops there. It doesn't publish them anywhere. So, I wrote a [GitHub action](https://github.com/marketplace/actions/alpine-package-releaser) to release Alpine Linux APKs to its repository page. I wanted to build an index page for the repository's packages, so I wrote [`tpl`](https://github.com/ivanvc/tpl) (interested on reading about it? [check my previous post](https://dev.to/ivanvc/bringing-go-templates-everywhere-365l)) to make this easy. And this is what it looks like:


![GitHub pages screenshot](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ei1jo52t15t6npv8uv97.png)


Given that [Alpine Linux doesn't keep previous versions of the packages](https://dev.alpinelinux.org/~clandmeter/other/forum.alpinelinux.org/forum/general-discussion/it-not-possible-install-old-version-packages.html); at work, we needed to lock some packages (i.e., Docker) to an old version. I thought this would also be an easy way to build and publish these packages.


Find the documentation at the [repository](https://github.com/ivanvc/abuild-releaser-action) and [GitHub's marketplace](https://github.com/marketplace/actions/alpine-package-releaser). Pull Requests and new features are welcome.

[![GitHub Repo](https://opengraph.githubassets.com/bdbcb8d1aae43dbf9d83e917a53a1ee933092df99d6efeab41ba5df3a02c82d8/ivanvc/abuild-releaser-action)](https://github.com/ivanvc/abuild-releaser-action)
Running MongoDB Locally with Podman: Quick Guide
Tags: mongodb, docker
Published: 2023-08-17 18:05:56


Welcome to our guide on setting up a local MongoDB server using Podman. 

**Step 1: Install Podman (if needed)**

Check Podman installation:
```bash
podman --version
```
If not installed, get Podman from [official instructions](https://podman.io/getting-started/installation)


**Step 2: Pull MongoDB Image**

Fetch MongoDB Community Server image:
```bash
podman pull docker.io/mongodb/mongodb-community-server:latest
```

**Step 3: Verify Image**

Confirm MongoDB image:
```bash
podman images
```

**Step 4: Run MongoDB Container**

Choose:

Option 1: No Volume (Data won't persist)
```bash
podman run --detach --name todoDB -p HOST_PORT:27017 docker.io/mongodb/mongodb-community-server:latest
```
Replace `HOST_PORT` with your preferred port number (e.g., 3000).

Option 2: With Volume (Data persists)
```bash
podman run --detach --name todoDB -p HOST_PORT:27017 -v /path/to/host/data:/data/db docker.io/mongodb/mongodb-community-server:latest
```
Replace `HOST_PORT` with your preferred port number (e.g., 3000).

**Understanding Port Mapping:**

- Use `-p HOST_PORT:27017` to map a port on your machine to port 27017 in the container.
- For example, `-p 3000:27017` maps port 3000 on your machine to port 27017 in the container.

Your MongoDB server is accessible at `mongodb://localhost:HOST_PORT` from your Node.js application using Mongoose or any MongoDB client.

**Volume vs. Non-Volume in MongoDB with Podman**

Choose wisely:

**Non-Volume Approach:**
- Data stored in container.
- Lost if container removed.
- For quick tasks, testing, or learning.

**Volume Approach:**
- Data stored outside container.
- Persists even if container removed.
- Recommended for development, production-like scenarios, or staging.

**Choosing:**
- Use Non-Volume: Quick tasks or learning.
- Use Volume: Persistent data needs.

Your choice depends on your use case. Your data, your decision.
MySQL Partitioning: Overview and Examples
Published: 2023-08-17 18:02:28

Partitioning extensive datasets into more manageable segments has become a common practice in modern data solutions. This strategic approach allows you to precisely focus on specific sections, rather than investing resources in navigating the entire dataset. Not only does this enable you to tailor your queries to the pertinent business requisites, thereby significantly enhancing the efficiency of your data management, but it also amplifies query performance, opening the path to improved scalability.

## Exploring MySQL Partitions: A Comprehensive Introduction

The technical aspect of achieving this lies in partitioning, a technique that divides the rows of a table (specifically, a MySQL table in this context) into multiple tables, or partitions, according to defined rules, and stores them at distinct locations. Importantly, the SQL layer treats the entire table as a unified entity, which means there's no discernible change in user experience.

Partitioning functions encompass the rules that need to be established, involving user-defined parameters as input. Subsequently, when you query specific data using SQL, the engine searches in the designated partitions. This results in a reduction in query processing time, a positive outcome for performance enhancement.

It's worth noting that partitioning proves particularly advantageous when dealing with significantly large quantities of rows. For smaller datasets of just a few thousand rows, the impact might not be as pronounced. However, as your dataset expands, the utility of partitioning becomes increasingly apparent.

Read more:
https://www.devart.com/dbforge/mysql/studio/partition-mysql.html
Is College Still Worth it? Tips from my 20 Years in Adult Education
Tags: education
Published: 2023-08-21 21:23:51

---
title: Is College Still Worth it? Tips from my 20 Years in Adult Education
published: true
date: 2023-08-17 17:46:36 UTC
tags: Education
canonical_url: https://www.freecodecamp.org/news/is-college-worth-it/
---

So many people ask me each week: is college still worth it? In this 1-hour video I answer this question and other commonly asked questions about university. I've been in adult education for two decades at this point, and even though I'm not a labor market economist, I do feel
Aprender a Programar con IAs
Tags: ai, programming, beginners, productivity
Published: 2023-08-17 17:45:13

Introducción
En la era digital actual, aprender a programar se ha convertido en una habilidad esencial para aquellos que desean incursionar en el mundo de la tecnología. Sin embargo, el camino hacia la maestría en programación puede ser desafiante y requiere dedicación. Afortunadamente, las Inteligencias Artificiales (IAs) han entrado en escena para revolucionar la forma en que aprendemos a programar, ofreciendo herramientas innovadoras que hacen que el proceso sea más accesible y efectivo que nunca.

Tabla de Contenido
Educación a partir de IAs
Tutoría Personalizada
Generación de Código
Resolución de Problemas

Educación a partir de IAs
Las IAs han demostrado su valía como aliadas en el proceso de aprendizaje de la programación. A continuación, exploraremos cómo las IAs están transformando la forma en que adquirimos habilidades de programación:

Tutoría Personalizada 
Las IAs tienen la capacidad de adaptarse a las necesidades y el nivel de cada estudiante. Proporcionan tutorías personalizadas, identificando áreas de fortaleza y debilidad para ofrecer ejercicios y prácticas específicas que ayuden a mejorar las habilidades de programación.

Generación de Código 
Una de las formas más impactantes en que las IAs están influyendo en el aprendizaje de la programación es mediante la generación de código automatizado. Herramientas como Blackbox pueden sugerir soluciones y ejemplos de código en tiempo real, permitiendo a los estudiantes comprender mejor la sintaxis y la estructura del código.

Resolución de Problemas 
Aprender a programar implica enfrentarse a desafíos y resolver problemas. Las IAs pueden proporcionar ejercicios interactivos y desafíos de resolución de problemas que ayuden a los estudiantes a aplicar sus conocimientos en situaciones del mundo real.


Aprende con Blackbox
Mientras exploramos las posibilidades de aprendizaje con IAs, es emocionante mencionar la herramienta Blackbox. Esta IA puede servir como tu asistente de programación, ayudándote a comprender conceptos difíciles, brindándote ejemplos de código y simplificando la curva de aprendizaje en programación.

Sigue tu viaje en el mundo de las IAs
¿Listo para comenzar tu viaje de aprendizaje de programación con la ayuda de IAs? ¡No dudes en aprovechar las ventajas de estas herramientas para acelerar tu crecimiento como desarrollador y lograr tus objetivos en el mundo de la programación!
AI in Code: Problem or Solution?
Tags: programming, productivity, discuss, ai
Published: 2023-08-17 17:40:32


Introduction
The integration of Artificial Intelligence (AI) in various domains has sparked debates and discussions about its impact. When it comes to the world of coding and programming, the question arises: Are IAs a potential problem or a promising solution? This article explores the role of AI in coding and examines how tools like Blackbox are shaping the landscape.

Table of Content
AI as a Coding Assistant
Code Generation and Exploration
Learning and Adaptation
Ethical Considerations

AI as a Coding Assistant: 
AI, such as Blackbox, is redefining how developers approach coding challenges. With the ability to provide suggestions, generate code snippets, and even spot errors, AI tools offer assistance that can significantly enhance efficiency and accuracy.

Code Generation and Exploration 
The advent of AI-powered code generation tools has simplified the coding process. Developers can now leverage AI algorithms, like those found in Blackbox, to create complex code structures and explore innovative solutions with ease.

Learning and Adaptation
AI's capability to learn from patterns and adapt over time is a game-changer. As developers interact with AI tools, like Blackbox, the AI learns from their coding style, preferences, and decisions, tailoring its assistance to match individual needs.

Ethical Considerations
While AI has proven to be a valuable aid, ethical concerns arise. Developers must consider the ethical implications of relying heavily on AI for coding tasks and ensure that the human touch remains integral to the coding process.



Find Solutions to your Problems with Blackbox
Blackbox, an AI-powered programming tool, exemplifies the potential benefits of integrating AI into coding. It offers developers a collaborative partner that streamlines coding tasks, enhances problem-solving, and accelerates development timelines.

Discover New Things In the AI World
As the debate over IAs in coding continues, it's crucial to engage in thoughtful discussions and explore the balance between human creativity and AI assistance. Embracing AI  can lead to innovative breakthroughs and amplify the capabilities of developers in the ever-evolving world of coding. Discover new ways of balancing the human and AI world with my articles!
Immutability with Init-Only Properties in C#
Tags: csharp, beginners
Published: 2023-08-17 17:33:01

In C#, immutability refers to the property of an object that once it is created, its state cannot be changed. This is typically achieved by making sure that the object's properties cannot be modified after the object is instantiated. One way to achieve immutability in C# is by using init-only properties, introduced in C# 9.0.

Init-only properties allow you to set the initial values of properties when an object is created, but they cannot be modified afterwards. This ensures that the object's state remains constant after it's been constructed. Here's how you can achieve immutability using init-only properties:

```
public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

```

In this example, the FirstName and LastName properties are declared as init-only properties using the init accessor. The constructor initializes these properties, and once the object is created, their values cannot be changed.

Here's how you can use this Person class:

```
var person = new Person("John", "Doe");

// This will result in a compilation error because init-only properties cannot be modified after initialization.
// person.FirstName = "Jane";

Console.WriteLine($"{person.FirstName} {person.LastName}");

```

Attempting to modify the FirstName property after initialization will result in a compilation error, enforcing the immutability of the object's state.

Init-only properties provide a convenient way to create immutable objects without the need to write custom getter methods and private setters, as was required in previous versions of C#. They improve code readability and maintainability by clearly indicating which properties are intended to be set only during object initialization.

Keep in mind that while init-only properties prevent you from directly modifying the property values, they do not make the entire object deeply immutable. If the properties themselves hold reference types (e.g., collections or other objects), those internal objects might still be mutable. If you want to ensure complete immutability, you need to ensure that the entire object graph is immutable.

Here is one more example which is mostly use in Domain Driven style codebase.

```
public abstract class Entity
{
    protected Entity(Guid id) => Id = id;

    protected Entity() { }

    public Guid Id { get; private init; }
}
```

Thanks for reading.
Get ready for Hacktoberfest 2023 with design2code2live
Tags: hacktoberfest23, hacktoberfest, webdeveloper, webdev
Published: 2023-08-17 17:26:01

---
title: Get ready for Hacktoberfest 2023 with design2code2live
published: true
description: Hacktoberfest 2023 with design2code2live
tags: hacktoberfest23, hacktoberfest, webdeveloper, webdev
cover_image: https://miro.medium.com/v2/resize:fit:640/format:webp/1*egrQcgTNGHfWLSXdjmPzGg.png
# Use a ratio of 100:42 for best results.
# published_at: 2023-08-17 17:19 +0000
---

A hearty welcome to each and every one of you as we step into Hacktoberfest 2023 👏

Introducing design2code2live, our open-source repository where I share designs and our incredible contributors bring them to life using HTML, CSS, and JavaScript.

Drawing inspiration from the remarkable achievements of Hacktoberfest 2022, our dedicated contributors turned over 60+ designs into fully functional websites. 🚀

A big round of applause and heartfelt gratitude to all the contributors who turned those designs into a website.

![2022](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/n6oobvq4epqds73ee26j.png)


![github](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wigzmewhldrjmsfl46xy.png)
Hacktoberfest 2022 Designs ☝️



Now let's enter into hacktoberfest 2023. Here we are planning to go for 100+ designs into websites with your help.


![do it gif](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hk5tp3i1n6gdg5d8idyp.png)

With your unwavering support and encouragement, let’s dive headfirst into this fest and create a wave of incredible achievements.

Join the discord server to be notified when the designs are available and also about the event. https://discord.com/invite/RfMEVfVGJk

And now, let’s talk about the exciting swag! Based on your contributions, we’ll be sending you a digital sticker — a super cool one at that!

![reward](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5v22fk7392zvegl8e0ij.png)

1 PR Merged: Level 1 Sticker
2 PRs Merged: Level 2 Sticker
4 PRs Merged: Level 3 Sticker
5 PRs Merged: Level 4 Sticker
6+ PRs Merged: PRO Level Sticker

All the stickers are digital and will be mailed after the event ends

Designs are in progress. Will keep you posted about the designs on my Twitter — https://twitter.com/@AravindkumarV09.
Securing PostgreSQL and Apache AGE: Best Practices for Database Security
Tags: postgres, postgressql, apacheage
Published: 2023-08-17 17:20:30

**Introduction**
Keeping your databases secure ensures that sensitive data is protected and unauthorized access is prevented. To ensure confidentiality, integrity, and availability of your data, this post discusses how to secure PostgreSQL and Apache AGE. Various security measures and techniques can be implemented to safeguard your database.

**Securing PostgreSQL**
We'll start by discussing essential security measures for PostgreSQL, including:

1. Authentication and Authorization: Configuring strong authentication methods, such as password-based authentication or certificate-based authentication. We'll also explore role-based access control (RBAC) and how to grant appropriate privileges to users and roles.

2. Encryption: Implementing encryption at rest and in transit to protect data from unauthorized access. We'll discuss options like Transparent Data Encryption (TDE) and SSL/TLS encryption for securing data.

3. Auditing and Logging: Enabling auditing and logging mechanisms to track and monitor database activities. We'll explore tools like pgAudit and discuss best practices for log management and analysis.

4. Patching and Updates: Keeping PostgreSQL up to date with the latest security patches and updates to address any known vulnerabilities.

**Securing Apache AGE**
Next, we'll focus on securing Apache AGE, the graph extension for PostgreSQL. We'll discuss specific considerations for securing graph databases, including:

1. Schema Design: Implementing proper schema design to ensure data integrity and prevent common security vulnerabilities like injection attacks.

2. Access Control: Applying access control mechanisms to restrict access to sensitive graph data. We'll explore how to define and enforce fine-grained access control policies using Apache AGE's capabilities.

3. Data Validation and Sanitization: Implementing data validation and sanitization techniques to prevent malicious input and protect against common security threats.

4. Secure Query Execution: Ensuring secure execution of queries by implementing parameterized queries and avoiding dynamic SQL generation.

**Database Hardening and Monitoring**
We'll discuss additional security measures that apply to both PostgreSQL and Apache AGE, including:

1. Network Security

2. Regular Backups

3. Intrusion Detection and Prevention

4. Security Audits and Penetration Testing

**Conclusion**
Securing your PostgreSQL and Apache AGE databases is essential to protect your data and maintain the trust of your users. In this post, we've explored best practices for securing both PostgreSQL and Apache AGE, covering authentication, encryption, auditing, patching, schema design, access control, and more.
Building a Google Translate Clone with ReactJS: Comprehensive Hindi Tutorial 🚀
Published: 2023-08-17 17:15:59

Hello dev.to community! 👋

I'm excited to share my journey in crafting a detailed and practical tutorial on building a Google Translate clone using ReactJS and MaterialUI.

Why this tutorial?
Depth: This isn't just a surface-level guide. We replicate not just the UI of Google Translate, but also a significant portion of its functionality. A virtual keyboard similar to Google's is also integrated, ensuring a complete experience.

Quality: Every tutorial is shot in 1440p60 for optimal clarity. Sound quality is also top-notch, recorded with a professional Fifine microphone.

Learning Curve: Alongside building the application, core React and JavaScript concepts such as Hooks - useState, useEffect, useRef, and debouncing techniques in JavaScript are delved into. It's a great mix of practical and theoretical!

Deployment: Wondering how to get your React application live for the world to see? I've got you covered with a dedicated segment on hosting React applications on Netlify for free.

Who is it for?
Whether you're a newbie to React or someone looking to deepen their understanding, this tutorial has got something for everyone. The total duration is 2.6 hours, segmented for easy consumption.

🎥 https://www.youtube.com/playlist?list=PLaBxiuYBVOR0_NCxCeh1yitRCUNIX8xzh

I genuinely hope this resource adds value to your learning journey. Feedback, questions, and collaboration opportunities are always welcomed! Let's grow and learn together.

Happy coding! 💻

#Reactjs #projecttutorial
Spread the object and omit keys
Tags: javascript, fundamentals
Published: 2023-08-17 17:10:44

---
title: Spread the object and omit keys
published: true
description: How to copy an object and omit some keys at the same time
tags: 
- javascript
- fundamentals
canonical_url: "https://www.geodev.me/blog/spread-object-and-omit-keys/"
---

Lastly I needed to create a shallow copy of an object but omit some keys. To make the code more compact I didn't want to use the `delete` operator. ES6 spread operator allows to do it.

Below is an example original object. I want to copy it but omit the `city` and `country` keys.

```javascript
const user = {
	age: 20,
	name: 'Garry',
	city: 'Copenhagen',
	country: 'Denmark'
};

const { city, country, ...userCopy } = user;

console.log(userCopy);

/**
{
    "age": 20,
    "name": "Garry"
}
**/
```

However, this solution creates new, unused variables (`city` and `country`) with their values:

```
console.log(city) // 'Copenhagen'
console.log(country) // 'Denmark'
```

Ideally we don't want to create any side effects. Here's the solution.

```javascript
function omitKeys(keys, obj) {
    const excluded = new Set(keys);
    return Object.fromEntries(Object.entries(obj).filter(e => !excluded.has(e[0])))
}

console.log(omitKeys(['city, country'], user));
/**
{
    "age": 20,
    "name": "Garry"
}
**/

console.log(city) // city is not defined;
console.log(country) // country is not defined;
```
Pezzo.ai is out of Beta! - The open-source, developer-first LLMOps platform
Tags: chatgpt, ai, opensource
Published: 2023-08-17 17:00:51

Pezzo.ai is out of Beta! - The open-source, developer-first LLMOps platform.

Struggling to add that sprinkle of LLM magic to your product? Pezzo is here to demystify the process.

Through building various LLM-driven products (such as autonomous agents, chatbots, content generators), I've experienced firsthand the gap between a basic proof of concept and a top-tier, production-grade product. And here's my insight: Crafting outstanding AI applications is not merely a data science issue; it's an engineering challenge.

Imagine what a small, talented team of full-stack developers can achieve with an OpenAI API key and expertly composed LLM. That's where Pezzo comes in to serve you!

✨ What is Pezzo?
Pezzo is an open-source, developer-first LLMOps platform. Here, your product teams can create, manage, monitor, evaluate, and optimize prompts effortlessly.
With Pezzo, AI delivery at scale becomes affordable and convenient, ensuring security, latency, reliability, and visibility. Even a single line of code can save you big! It's time to adopt AI smoothly with your team.

🌎 Pezzo's Website: https://pezzo.cc/3QHEyRi
👩‍💻 Pezzo on GitHub: https://pezzo.cc/3qIWNv3
🌐 Docs: https://pezzo.cc/3qDCQWD

Support Pezzo:
🌟 Star us on GitHub to express your support!
💬 Signup and let us know what you think ❤️