teleren/devto huggingface dataset:
About Python
Tags: beginners, tutorial, python, programming
Published: 2024-01-15 16:28:17

### Python: A Journey Through Time and Passion

Hey there! So, you've decided to dive into the captivating world of Python, and I couldn't be more excited for you! Let's take a stroll down the enchanting path of Python's history and evolution – it's a tale of triumph, community, and sheer programming magic. I know this is unnecessary, but believe me, it is gonna help you in the long run. _ChatGPT was used to assist me while making this post
_
**Once Upon a Time...**
Python's story began in the late 1980s when a brilliant mind named Guido van Rossum envisioned a language that was not just powerful but also remarkably readable. Imagine a world where code is as clear as day, and syntax feels like poetry – that was Guido's dream.

**A Love Letter to Simplicity**
Fast forward to the 1990s, Python was officially born, and it quickly won the hearts of developers. Why? Because it's just so darn readable! The syntax is designed to be human-friendly, making it a breeze for beginners and a joy for seasoned programmers. Writing Python feels like crafting art rather than lines of code.

**Python's Rise to Stardom**
As the new millennium unfolded, Python started weaving its charm across various domains. Its simplicity and versatility turned it into a favorite not just among developers but also educators, data scientists, and AI enthusiasts. Python became the cool kid on the programming block, and everyone wanted to be a part of its journey.

**Community: Where Magic Happens**
Ah, the Python community – a vibrant, welcoming, and downright passionate bunch. It's not just a group of developers; it's a family. From online forums to local meetups, the Python community is there for you, ready to help, guide, and share in the triumphs and challenges of coding life. Feeling stuck? Someone in the community has been there, done that, and is more than happy to lend a hand.

**Diverse Applications: Python's Playground**
Python isn't just a language; it's a toolbox of wonders. From web development to data science, machine learning to artificial intelligence – Python is everywhere, and it plays oh-so-nicely with others. You want to build a website? Python's got your back. Dive into the vast ocean of data? Python's your trusty companion. The possibilities are as boundless as your imagination.

**My Love Affair with Python**
Python, to me, is more than a programming language; it's a companion in my coding adventures. It has this innate ability to make the complex seem simple, to turn challenges into puzzles waiting to be solved. The thrill of writing Python code is like composing a symphony – each line contributing to a masterpiece.

So, welcome to the Python family! As you embark on this journey, remember: Python is not just a language; it's an experience, a community, and a canvas for your programming dreams. Buckle up, and get ready for an exhilarating ride through the realms of Pythonic wonder. Happy coding! 🐍✨
Mastering Git: The Power of Interactive Rebase
Tags: git, versioncontrol, codingbestpracctices, devcommunity
Published: 2024-01-15 16:19:58

## Unraveling the Magic of `git rebase -i`

Hello Devs,

Today, let's dive deep into one of Git's most powerful and transformative features: **Interactive Rebase**. Understanding `git rebase -i` can elevate your workflow, allowing you to maintain a clean and understandable commit history, which is a hallmark of professional development practice.

### What is `git rebase -i`?

`git rebase -i`, where `-i` stands for interactive, is a command that rewrites the commit history of your current branch. It opens up a realm where you can squash commits, edit messages, reorder, or even drop commits entirely. This interactive mode serves as a control panel for tailoring your commit history.

### Why Use Interactive Rebase?

1. **Clean and Clear History:** A streamlined commit history makes it easier for others (and future you!) to understand the evolution of your project.
2. **Combining Commits:** Squashing related commits into a single commit keeps the history concise and relevant.
3. **Rewriting History:** Correcting previous commit messages or content to add clarity or rectify mistakes.
4. **Logical Sequence:** Ensuring your commits are in an order that makes sense for the project's progression.

### How to Use `git rebase -i`

1. **Initiate Rebase:** Start with, e.g., `git rebase -i HEAD~5` to rebase the last five commits.
2. **Interactive Editing:** The editor allows you to pick, squash, reword, edit, or drop commits.
3. **Apply Changes:** After editing, Git replays these commits according to your specifications.
4. **Resolve Conflicts:** In case of conflicts during rebasing, resolve them before continuing.

### Best Practices and Cautions

- **Never Rebase Public History:** Rebasing rewrites history. Avoid rebasing commits that are already pushed to a shared repository.
- **Backup Branch:** Create a backup before starting the rebase, just in case things go south.

### Practical Example

Let's say you have a series of commits like adding features and fixing typos. Using `git rebase -i`, you can squash the typo fixes into their respective feature additions, making the history cleaner and more meaningful.

### Wrapping Up

`git rebase -i` is a tool of precision and power in the hands of a developer. It allows us to maintain a clean, professional commit history, an essential part of collaborative coding. However, it's a tool that comes with its responsibilities. Use it wisely, especially when dealing with branches shared by multiple collaborators.

Remember, mastering tools like Git not only improves your workflow but also enhances team collaboration and code quality. So next time you find yourself with a messy commit history, consider giving `git rebase -i` a try. It's a game-changer!

Happy coding!

---

I hope this blog post provides a comprehensive and engaging overview of `git rebase -i` for your readers on 'dev.to'. Remember to tailor it with your personal experiences or additional insights to make it uniquely yours!
Mastering Git: Commit Message Types and Git Flow Branch Naming
Tags: git, versioncontrol, programming, bestpractices
Published: 2024-01-15 16:04:59

**Introduction**

In the world of software development, mastering Git is akin to having a superpower. Git not only helps in version controlling but also in maintaining a healthy and understandable project history. A significant part of this mastery lies in understanding commit message types and the Git Flow branch naming conventions. This post delves into these aspects to enhance your Git prowess.

---

**Committing with Clarity: Understanding Git Commit Message Types**

**Git commit message types** serve as a beacon of understanding in the sea of changes that is a software project. These types not only categorize the changes made but also communicate the intent and scope of each commit to your team. Here are the common types you'll encounter:

1. **feat**: Introducing new features or significant improvements.
2. **fix**: Bug fixes that resolve issues in your code.
3. **docs**: Updates or additions to documentation.
4. **style**: Cosmetic changes that don't affect code functionality (like formatting).
5. **refactor**: Code changes that neither fix a bug nor add a feature but improve structure.
6. **test**: Everything about testing - adding or fixing tests.
7. **chore**: Routine tasks or updates to the build process.
8. **perf**: Enhancements that improve performance.
9. **ci**: Modifications related to CI/CD processes.
10. **build**: Changes affecting the build system or external dependencies.
11. **revert**: Undoing previous changes.

---

**Streamlining Workflow with Git Flow Branch Naming Conventions**

**Git Flow** is a branching strategy that helps manage and structure various phases of a project. It's a framework that utilizes specific branch types, each with its distinct role and naming convention:

1. **master**: The source of truth for production-ready states.
2. **develop**: The integration branch for development work.
3. **feature/**: For developing new features, e.g., `feature/add-login`.
4. **release/**: Preparing a new production release, e.g., `release/1.2.0`.
5. **hotfix/**: Quick fixes for the production version, e.g., `hotfix/critical-login-bug`.
6. **support/**: Long-term support for older versions, e.g., `support/1.x`.
7. **bugfix/**: For specific bug fixes (optional), e.g., `bugfix/login-error`.

---

**Conclusion**

Both commit message types and branch naming conventions in Git are not just about keeping things organized; they're about communicating with your team and your future self. They tell a story about the decisions made during the development process and make navigating the project history easier. Whether you're a solo developer or part of a large team, adopting these practices will undoubtedly make your

development journey smoother and more efficient.

Remember, these are not just conventions but tools for effective collaboration. By using clear commit messages and structured branches, you not only make your repository more readable but also foster a more organized and professional workflow. 

Happy coding, and may your Git journey be smooth and successful!
PHP on Manjaro with ASDF
Tags: php, manjaro, environment, asdf
Published: 2024-01-15 15:52:22

Install this libraries for that PHP works

`yay -S base-devel libpng postgresql-libs re2c gd oniguruma libzip libsodium`

and next add the asdf plugin for PHP

`asdf plugin-add php https://github.com/asdf-community/asdf-php.git`

and install the PHP with this command

`asdf install php 8.3.1`
Browser'daki Console İle Çalışmak
Tags: javascript, console
Published: 2024-01-15 15:52:16

Bu eğitimde, mesajları görüntülemek için web geliştirme araçlarının Console sekmesini nasıl açacağınızı öğreneceksiniz.

Web geliştirme araçları, JavaScript kodunu test etmenize ve hata ayıklamanıza olanak tanır. Web geliştirme araçlarına genellikle geliştirici araçları denir.

Google Chrome, Firefox, Edge, Safari ve Opera gibi modern web tarayıcıları, geliştirme araçlarını yerleşik özellikler olarak sağlar.

Genel olarak geliştirme araçları HTML, CSS, DOM ve JavaScript gibi çeşitli web teknolojileriyle çalışmanıza olanak tanır.

Bu eğitimde, JavaScript tarafından gönderilen mesajları görüntülemek için geliştirici araçlarının Konsol sekmesini nasıl açacağınızı öğreneceksiniz.

## Google Chrome

Öncelikle devtools.html dosyasını açın.

`devtools.html` dosyası aşağıdaki JavaScript koduna sahiptir:

```
<script>
    console.log('Hello, devtools!');

    // the following code causes an error
    let greeting = msg;
</script>
```
İkinci olarak, Windows'ta `F12`'ye veya Mac'teyseniz `Cmd+Opt+J` tuşlarına basın.

Geliştirici araçları varsayılan olarak Konsol sekmesini açacaktır. Bunun gibi görünecek:


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

İlk mesaj `Hello DevTools!` aşağıdaki komutun çıktısıdır:

```
console.log('Hello, DevTools!');
```
Değişkenin değerinin çıktısını almak için aşağıdaki `console.log()` yöntemini kullanırsınız. Örneğin:

```
let message = 'Good Morning!';
console.log(message);
```

Konsol sekmesinde görünen ikinci mesaj bir hatadır.

```
Uncaught ReferenceError: msg is not defined
```

Bunun nedeni, `msg` değişkeninin kodda tanımlanmamış olması ancak atamada referans verilmiş olmasıdır.

Artık `console.log()` tarafından verilen normal mesajları ve hata mesajlarını görebilirsiniz. Başlamak yeterli. Daha sonraki eğitimde geliştirme araçlarına dalacağız.

## Firefox and Edge

Tipik olarak Firefox ve Edge'deki geliştirici araçlarının Konsol sekmesini `F12`'yi kullanarak açarsınız. Benzer kullanıcı arayüzlerine sahiptirler.

## Safari

Mac'te Safari tarayıcısı kullanıyorsanız öncelikle Geliştirici Menüsünü etkinleştirmeniz gerekir:

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

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

Daha sonra Konsol penceresine geçiş yapmak için `Cmd+Opt+C` tuşlarına basın:

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

Bu eğitimde, JavaScript kodu tarafından yayınlanan mesajları kontrol etmek için geliştirici araçlarının Konsol sekmesini nasıl açacağınızı öğrendiniz.

[Github JS Eğitimleri](https://github.com/haktantekin/javascript-tutorial/tree/main)

[Linkedin](https://www.linkedin.com/in/haktantekin/)

[Kaynak](https://www.javascripttutorial.net/web-development-tools/)
How to Safely Edit a Git Commit Message After Pushing *Demystifying one of the tricky aspects of Git*
Tags: git, versioncontrol, devtips, collaboration
Published: 2024-01-15 15:46:30

**Introduction**

Hello, Devs! Today, we're diving into a common Git scenario: you've made a commit, pushed it to your repository, and then realized that the commit message needs to be changed. Whether it's a typo, a missing detail, or just a clearer description, editing a commit message after it's been pushed can seem daunting. But don't worry, I'm here to guide you through the process step-by-step.

---

**Why Edit a Commit Message?**

Commit messages are crucial in maintaining a clear and understandable history of your project. They should accurately reflect the changes made. Therefore, ensuring they are precise and informative is essential for team collaboration and future reference.

---

**Step-by-Step Guide**

1. **Local Commit Amendment**

    If you need to edit the most recent commit message:

    ```bash
    git commit --amend -m "New commit message"
    ```

    For editing an older commit, use the interactive rebase:

    ```bash
    git rebase -i HEAD~N  # Replace N with the number of commits to go back
    # Follow the instructions in the interactive rebase to edit the commit message
    ```

2. **Force Pushing Changes**

    After amending your commit:

    ```bash
    git push --force
    ```

    **Warning:** Force pushing changes the history on the remote repository. This can cause issues for others working on the same branch.

---

**Best Practices and Team Communication**

- **Avoid Rewriting Public History:** As a rule of thumb, avoid rewriting the history of public branches. It's best used for local or personal branches.

- **Communicate with Your Team:** If you're working in a team, make sure to inform everyone about the changes. They will need to sync their local copies to the updated history.

- **Use Clear Commit Messages:** Going forward, ensure your commit messages are clear and descriptive from the start to minimize the need for such amendments.

---

**Conclusion**

Editing a pushed Git commit message might seem intimidating, but it's a handy skill in your development toolkit. Use it judiciously, and always keep your team in the loop. Remember, clear commit messages are the hallmark of a well-maintained project!

Happy coding!
Next.js: Internationalisation (i18n) for the `app directory`
Tags: nextjs, i18n, webdev, react
Published: 2024-01-15 15:44:57

**A while ago, we released `version 3.0.0` of `next-export-i18n`, the _most popular_ i18n module for Next.js, which is _fully compatible with next export_.**

`Version 3.0.0` fully supports the `app directory` and comes with the highly sought-after feature of storing the selected language in `localStorage` instead of the `search parameter` on the URL.
 
## The case for next-export-i18n 
Since `v10.0.0` Next.js has an out-of-the-box support for internationalised (i18n) routing and it streamlines the touring and locale parsing for nearly all existing l18n library solutions available for Next.js, for example, `react-intl`, `react-i18next`, `lingua`, `rosetta`, `next-intl`.
  
Those are amazing libraries, but unfortunately, `next.js' i18n-routing` does not support statically exported pages that you create with `next export` or the `config: export` property.

With `next-export-i18n`, you can easily add internationalisation (i18n) to your h actual static exported pages by operating exclusively on the client side. 

## For the `page router`
In case you're using the `page router` please use `version 2.x` of `next-export-i18n` with `npm install --save-dev next-export-i18n@^2`

## Migrating your code 
In case you're migrating from the `page router` to the `app directory`, please look at the [2.x to 3.x Migration guide](https://github.com/martinkr/next-export-i18n/blob/main/migration-guide.md).
Right Click import from excel
Tags: uyumsoft
Published: 2024-01-15 15:36:20

> ERP Sağ klik Excelden al fonksiyonu
```
var returnValueStr ="\tTatil\tÖRNEK ADRES11\t\tÖRNEK ADRES33\tTÜRKİYE\n\Tatil\tÖRNEK ADRES55\t\tÖRNEK ADRES66\tTÜRKİYE"	

GetControl('EntityAdressCollection').PerformCallback('PasteFromExcel|' + returnValueStr);


var returnValueStr ="\Tatil\tÖRNEK ADRES11\t\tÖRNEK ADRES33\tTÜRKİYE\n\tankara migros\tÖRNEK ADRES55\t\tÖRNEK ADRES66\tTÜRKİYE\n"

GetControl('EntityAdressCollection').PerformCallback('PasteFromExcel|' + returnValueStr);



var returnValueStr ="\t10\tS\t10-001\t00 10 0025 001\t\tKG\t1234\tTRY\tHariç\t08-KDV\t123\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n"	

GetControl('OfferDCollection').PerformCallback('PasteFromExcel|' + returnValueStr);
```
Ibuprofeno.py💊| #23: Explica este código Python
Tags: python, spanish, beginners, learning
Published: 2024-01-15 15:35:06

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

```py
## Reto #23

persona = {
  "nombre": "Cris",
  "apellido": "Villca",
  "edad": 27,
  "soltero": False,
  "direccion": {
    "calle": 17,
    "avenida": "Tomas Monje",
    "pasaje": "A"
  }
}

print(persona.get("peso", 50))
```

- A. `peso`
- B. `None`
- C. `50`
- D. `TypeError`

---

Respuesta en el primer comentario.
Javascript Kod Editörleri
Tags: javascript
Published: 2024-01-15 15:26:08

Bu eğitimde, JavaScript kod düzenleyicilerini ve JavaScript kodlamak için Visual Studio Code'un nasıl kurulacağını öğreneceksiniz.

## Popüler JavaScript Kod Düzenleyicileri

JavaScript kaynak kodunu düzenlemek için Windows'ta Not Defteri gibi bir düz metin düzenleyicisine ihtiyacınız vardır. Ancak, JavaScript kodunun yazımını basitleştirmek ve hızlandırmak için bir JavaScript kod düzenleyicisine ihtiyacınız vardır.

Temel düzenleme özelliklerinin yanı sıra, bir JavaScript kod düzenleyicisi size sözdizimi vurgulama, girintileme, otomatik tamamlama ve küme ayracı eşleştirme işlevleri sağlar. Bazı düzenleyiciler ayrıca JavaScript'te hata ayıklamanıza da izin verir.

Aşağıda bazı popüler JavaScript kod düzenleyicileri verilmiştir:

- Visual Studio Code
- Atom
- Notepad++
- Vim
- GNU Emacs

Tüm bu JavaScript editörlerinin ücretsiz olduğunu unutmayın. Tercih olarak Visual Studio Code'u kullanacağız.

## Visual Studio Code

Visual Studio Code, Microsoft tarafından geliştirilen ücretsiz ve açık kaynaklı bir kod düzenleyicisidir. Visual Studio Code'a genellikle VS Code denir.


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

VS Code, Windows, Linux ve macOS gibi platformlarda çalışır.

VS Kodu son derece özelleştirilebilir. Temayı, klavye kısayollarını ve tercihleri değiştirmenize olanak tanır. Düzenleyiciye ekstra işlevsellik katan birçok kullanışlı uzantıya sahiptir.

VS Code, IntelliSense, hata ayıklama, biçimlendirme, kodda gezinme, yeniden düzenleme ve diğer birçok gelişmiş dil özelliğini içeren yerleşik JavaScript desteğini içerir.

VS kodu tarafından desteklenen tüm özellikleri öğrenmek için Visual Studio Code'daki [Javascript](https://code.visualstudio.com/docs/languages/javascript)'e göz atarsınız.

## Visual Studio Code İndirme

Visual Studio Code'u indirmek için aşağıdaki indirme bağlantısına gidin:

[VSCode Yükle](https://code.visualstudio.com/download)

## Visual Studio Kodunu Yükleme

Visual Studio Code'u ayarlamak kolay ve hızlıdır. Küçük bir indirme olduğundan birkaç dakika içinde yükleyebilirsiniz.

## Live Server Eklentisini Yükleme

Live Server uzantısı, statik sayfalar için çalışırken yeniden yükleme özelliğine sahip bir geliştirme yerel sunucusu başlatmanıza olanak tanır. JavaScript kodunu değiştirdikten sonra değişiklikleri görmek için sayfayı yenilemenize gerek yoktur.

Live Server uzantısını yüklemek için şu adımları izleyin:

- İlk önce Uzantılar'ı tıklayın.
- İkinci olarak, Canlı Sunucuyu arayın ve listeden Canlı Sunucu uzantısını seçin.
- Son olarak Install butonuna tıklayın.


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

Bu öğreticide, JavaScript kod düzenleyicisini ve JavaScript kaynak kodunu düzenlemek için Visual Studio Code'un nasıl kurulacağını öğrendiniz.

[Github JS Eğitimleri](https://github.com/haktantekin/javascript-tutorial/tree/main)

[Linkedin](https://www.linkedin.com/in/haktantekin/)

[Kaynak](https://www.javascripttutorial.net/what-is-javascript/)
Navigating the Database Landscape: Relational vs. Non-relational
Tags: beginners, learning, database, productivity
Published: 2024-01-15 15:25:53

1.**Data Model:**

- **Relational Databases (RDBMS):**Organize data into structured tables with rows and columns. Data relationships are established through keys.

- **Non-relational Databases (NoSQL):**Use various data models, such as document-oriented (like MongoDB), key-value pairs (like Redis), wide-column stores, or graph databases. The structure is more flexible and can adapt to different types of data.

2.**Schema:**

- **Relational Databases:**Require a predefined schema where the structure of tables and relationships between them is defined before inserting data.

- **Non-relational Databases:**Typically have a dynamic or schema-less approach, allowing flexibility to add fields on the fly.

3.**Scalability:**

- **Relational Databases:**Traditionally scale vertically by adding more power to a single server (vertical scaling). Some modern relational databases also support horizontal scaling across multiple servers.

- **Non-relational Databases:**Primarily designed for horizontal scaling, allowing the distribution of data across multiple servers or nodes.

4.**Use Cases:**

- **Relational Databases:** Well-suited for complex queries and transactions where data integrity is critical. Commonly used in applications with well-defined structures like financial systems.

- **Non-relational Databases:**Ideal for scenarios with dynamic and evolving data, high scalability requirements, and where a quick and flexible data model is essential, such as in web applications with varying data types.

5.**Examples:**

- **Relational Databases:**MySQL, PostgreSQL, Oracle, Microsoft SQL Server.

- **Non-relational Databases:**MongoDB, Cassandra, Redis, CouchDB.