DEV Community: The Eagle 🦅

Manual de supervivencia Git de Ned 📚

The Eagle 🦅 — Mon, 16 Sep 2024 14:06:02 +0000

Introducción

¡Bienvenido a al Manual de supervivencia de Git de Ned! 📚 En este manual, aprenderás comandos esenciales de Git como git checkout y git restore para deshacer cambios, git stash para guardar trabajo no commiteado temporalmente, git cherry-pick para extraer commits específicos de una rama a otra y git reflog para recuperar "commits perdidos". Ya sea que estés corrigiendo un error, cambiando prioridades porque tu jefe lo decidió, o restaurando código eliminado, estos comandos te ayudarán a manejar escenarios comunes con confianza. ¡Así que, adentrémonos y dominemos Git juntos!

Esto es lo que aprenderemos hoy:

Índice 📋

Episodio 1: Primer Día de Trabajo y Errores
- Usando git checkout para restaurar archivos de un commit anterior.
- Guardar cambios no commiteados con git restore.
Episodio 2: Tenemos una Nueva Prioridad, Houston
- Cómo guardar archivos no rastreados con git stash.
- Gestionar stashes y recuperarlos cuando sea necesario.
Episodio 3: ¡Crisis de CoolFeature!
- Usar git cherry-pick para seleccionar y aplicar commits específicos.
Episodio 4: El Drama de "Cambié de Opinión"
- Recuperar commits eliminados con git reflog.
Conclusión

Episodio 1: Primer Día de Trabajo y Errores

Supongamos que estamos construyendo una aplicación de mapas para tu lugar de trabajo, y tenemos la siguiente estructura de carpetas:

Refactorizamos nuestro archivo main.tsx porque queremos que MapsApp.tsx sea nuestro archivo principal de aplicación, pero accidentalmente introducimos un error.

No nos damos cuenta y procedemos a hacer commit y push al repositorio remoto:

(Por si tienes curiosidad, estoy usando gitmoji para mensajes de commit geniales.)

Ahora, ejecutas tu proyecto y te das cuenta de que hay un error en main.tsx porque la consola te lo dice, pero por alguna razón, no puedes encontrarlo—tal vez estás nervioso, así que...

¿Qué puedo hacer para que no me regañen?

Consejo #1: Restaurar Archivos Salva Vidas

En este escenario, para simplificar, supongamos que ya has hecho push del proyecto antes de la refactorización como buena práctica (de lo contrario, estás en problemas). Usas git log, y te muestra lo siguiente:

Dado que tienes un archivo anterior bueno, simplemente puedes usar git log y seleccionar el commit hash que deseas restaurar. En nuestro caso, es este:

Luego, procede a escribir:

git checkout 4d7490e src/main.tsx

¡Y lo has restaurado—tadaa!

Oye, solo tengo un commit en mi proyecto, ¿puedo revertirlo?

Consejo #2: Usa `git restore` para Cambios No commiteados

Tienes los siguientes cambios no commiteados en main.tsx:

Puedes confirmar que están no commiteados con un git status:

Y tu git log solo tiene el primer commit, donde creaste tu proyecto:

Tienes dos opciones, una fácil y una difícil:

# La fácil
git restore src/main.tsx
# La difícil
git checkout -- src/main.tsx

Voy con restore:

¡Ahora nuestro archivo está limpio de nuevo! ¡Hurra!

Episodio 2: Tenemos una Nueva Prioridad, Houston

Ahora, tu jefe o líder de equipo decide que es un buen día para cambiar las prioridades (porque eso es lo suyo). Supongamos que estás creando una nueva página llamada MyCoolPage.tsx:

Ahora, tienes que decidir: ¿Debería hacer commit y luego rebasear los commits, seleccionar los que quiero y hacer squash para que quede limpio?

Voy a perder demasiado tiempo solo para ese cambio más adelante, ¿Qué puedo hacer?

Consejo #3: Guárdalo, Hermano

¡Ten cuidado en este caso! Este ejemplo especial implica la creación de un nuevo archivo que no existe en tu repositorio, así que necesitas usar:

git stash --include-untracked
# O la bandera más corta
git stash -u

Ahora, puedes ver que el archivo ya no está con nosotros:

Pero si escribes:

git stash list

Todavía está aquí:

El nombre del stash es stash@{0}.

Ahora, tenemos múltiples opciones:

# Podemos extraer el stash y eliminarlo de la lista con un simple
git stash pop
# O aplicarlo y dejarlo en la lista para que podamos acceder a él más tarde con
git stash apply stash@{número de tu stash}

Voy con pop, y puedes ver que ha vuelto:

Cuando intento usar git stash list, no muestra nada porque al final fue extraído de la lista:

Episodio 3: ¡Crisis de CoolFeature!

Estás trabajando en una rama diferente para una característica llamada feature/myCoolFeature, que tiene tres requisitos. Ya has completado dos de ellos, así que tienes dos commits en esa rama.

Ahora, tu jefe te dice: Oye, necesitamos la CoolFeature que implementaste desde tu rama, pero solo la primera, ¡y la necesitamos ahora!

Podrías crear una rama desde la actual, eliminar el commit HEAD y fusionarlo en main, pero eso es demasiado para una tarea tan simple.

Oh, hombre, necesito tiempo para esto y ellos lo necesitan ahora, ¿hay una forma más rápida?

Consejo #4: Usa Cherry-Pick para Obtener Ese Commit

Ve a tu rama main con git checkout main y obtén el log de la otra rama con:

git log feature/myCoolFeature

Luego, selecciona el commit específico:

git cherry-pick 714cf87

¡Y Linus Torvalds (creador de Git y Linux) salva el día de nuevo! Y si usas git log, puedes ver que tus cambios están allí:

Episodio 4: El Drama de "Cambié de Opinión"

Supongamos que creaste una nueva característica:

La agregas y haces

commit, pero cambias de opinión y decides eliminarla, así que procedes a buscar en Google cómo eliminar un commit. Encuentras que con un git reset --hard HEAD~1, procedes a usarlo.

Estás bien hasta que te das cuenta de que quieres reutilizar algo de código, pero ahora cuando usas git log, no puedes encontrarlo. Piensas:

Se ha ido para siempre, ahora voy a perder tiempo...

Consejo #5: Si No Lo Encuentras en `git log`, Es Hora de `reflog`

Solo revisa la magia de este comando:

git reflog

Ahora tienes el hash para restaurar tu commit:

¡Otro final feliz!

Conclusión 🎓

¡Felicidades, has aprobado tu manual de supervivencia Git! 🎉 Al igual que el manual de supervivencia Escolar de Ned 📚, ahora tienes un buen conjunto de herramientas para navegar por los complicados pasillos del control de versiones. Desde usar git checkout para corregir esos errores accidentales, guardar cambios no commiteados como un profesional, hacer cherry-pick de commits cuando la presión es alta, hasta rescatar trabajos perdidos con git reflog, estás listo para enfrentar cualquier desafío de Git con confianza. Así que, pon en práctica estos consejos y mantén tus proyectos funcionando sin problemas.

Agradecimientos especiales a Midu sin su libro de Git, no habría podido hacer este artículo. 🙏💻✨

¡Gracias por leer!

Déjame saber herman@, tus pensamientos o cualquier sugerencia sobre Git en los comentarios abajo 👇

Ned's Declassified Git Survival Guide 📚

The Eagle 🦅 — Fri, 13 Sep 2024 22:20:21 +0000

Introduction

Welcome to Ned's Declassified Git Survival Guide! 📚 In this guide, you'll learn essential Git commands like git checkout and git restore to undo changes, git stash to save uncommitted work temporarily, git cherry-pick🍒 to pull specific commits from one branch to another, and git reflog to recover "lost commits". Whether you're fixing a bug 🐞, changing priorities because your manager decided that, or restoring deleted code, these commands will help you handle common real-case scenarios with confidence 💪. So, let’s dive in and master Git together!

This is what we'll learn today:

Index 📋

Episode 1: First Day of Work & Bugs
- Using git checkout to restore files from a previous commit.
- Saving uncommitted changes with git restore.
Episode 2: We've Got a New Priority, Houston
- How to stash untracked files with git stash.
- Managing stashes and retrieving them when needed.
Episode 3: The CoolFeature Crisis!
- Using git cherry-pick to select and apply specific commits.
Episode 4: I Changed My Mind Drama
- Recovering deleted commits with git reflog.
Conclusion

Episode 1: First Day of Work & Bugs

Let's say we're building a Map Application for your workplace, and we have the following folder structure:

We refactor our main.tsx file because we want MapsApp.tsx to be our main application file, but we accidentally introduce a bug.

We don't realize it and proceed to commit and push it to the remote repository:

(In case you're curious, I'm using gitmoji for cool commit messages.)

Now, you run your project and realize there's a bug in main.tsx because the console tells you, but for some reason, you can't find it—maybe you're nervous, so...

What can I do so I don't get yelled at?

Advice #1: Restoring Files Saves Lives

In this scenario, for simplicity, let's say you've already pushed the project before the refactor as a good practice (otherwise, you're in trouble). You use git log, and it shows you the following:

Since you have a previous good file, you can simply use git log and select the commit hash that you want to restore. In our case, it's this one:

Then, proceed to write:

git checkout 4d7490e src/main.tsx

And you've restored it—tadaa!

Hey, I've only got one commit in my project, can I reverse that?

Advice #2: Use `git restore` for Uncommitted Changes

You have the following uncommitted changes in main.tsx:

You can confirm they are uncommitted with a git status:

And your git log only has the first commit, where you created your project:

You have two options, one easy and one hard:

# Easy one
git restore src/main.tsx
# Hard one
git checkout -- src/main.tsx

I'll go with restore:

Now our file is clean again! Hooray!

Episode 2: Hey, We've Got a New Priority, Houston

Now, your manager or team leader decides it's a good day to change priorities (because that’s their thing). Let's say you're creating a new page called MyCoolPage.tsx:

Now, you have to decide: Should I commit this and then rebase the commits, pick the ones I want, and squash them to make it clean?

I'm Going to Spend Too Much Time Just for That Change Later On, What Can I Do?

Advice #3: Stash It, Bro

Be careful in this case! This special example involves creating a new file that doesn't exist in your repository, so you need to use:

git stash --include-untracked
# Or the shorter flag
git stash -u

Now, you can see the file is no longer with us:

But if you write:

git stash list

It's still here:

The name of the stash is stash@{0}.

Now, we've got multiple options:

# We can pop the stash and remove it from the list with a simple
git stash pop
# Or apply it and let it stay in the list so we can access it later with
git stash apply stash@{number of your stash}

I'll go with pop, and you can see it's back:

When I try to use git stash list, nothing shows up because it ultimatewas popped from the list:

Episode 3: The CoolFeature Crisis!

You're working in a different branch for a feature called feature/myCoolFeature, which has three requirements. You've already completed two of them, so you have two commits in that branch.

Now, your manager tells you: Hey, we need the CoolFeature you implemented from your branch, but only the first one, and we need it now!

You could create a branch from your current one, delete the HEAD commit, and merge it into main, but that’s too much for such a simple task.

Oh man, I need time for this and they need it now, is there a faster way?

Advice #4: Use Cherry-Pick to Get That Commit

GitSurvivalGuide
Go to your main branch with git checkout main and get the log from the other branch with:

git log feature/myCoolFeature

Then, cherry-pick the specific commit:

git cherry-pick 714cf87

And Linus Torvalds (creator of Git & Linux) saves the day again! And if you use git log, you can see your changes are there:

Episode 4: The “I Changed My Mind” Drama

Let's say you created a new feature:

You add and commit it, but you change your mind and decide to delete it, so you proceed to Google and search how to delete a commit. You find that with a git reset --hard HEAD~1, you proceed to use it.

You're fine until you realize that you want to reuse some code, but now when you use git log, you can't find it. You think:

It's gone forever, now I'm going to waste time...

Advice #5: If You Can't Find It in `git log`, It's Time to `reflog`

Just check the magic of this command:

git reflog

Now you've got the hash to restore your commit:

Another happy ending!

Conclusion 🎓

Congrats dawg, you've just aced your Git survival guide! 🎉 Just like Ned’s Declassified School Survival Guide 📚, you now have a nice toolkit to navigate the tricky hallways of version control. From using git checkout to fix those accidental missteps, stashing away uncommitted changes like a pro, cherry-picking commits when the pressure's on, to rescuing lost work with git reflog, you're set to tackle any Git challenge with confidence. 📚🛠️ So, put these tips into practice and keep your projects running smoothly.

Special thanks to Midu without his Git book, I wouldn't have made this article. 🙏💻✨

Thank you for reading!

Let me know, dawg, your thoughts or any suggestions about Git in the comments down below 👇

Clean Code vs Mejores Prácticas: ¿Cuál es la Diferencia?

The Eagle 🦅 — Sun, 08 Sep 2024 11:58:04 +0000

En el desarrollo de software, "Clean Code" y "Mejores Prácticas" son dos conceptos importantes. A veces podrías escuchar comentarios como "Buen trabajo, tu código se ve limpio" o "Aplica mejores prácticas para evitar la deuda técnica la próxima vez". Aunque se superponen, cada uno juega un papel único en la creación de software de alta calidad y mantenible. Vamos a desglosar lo que significa cada término, explorar algunos ejemplos ilustrativos y ver cómo difieren.

¿Qué es "Clean Code"? 📚

"Clean Code" es un libro de Robert C. Martin (Uncle Bob) que proporciona directrices para escribir código que sea fácil de leer, entender y mantener. Aquí hay ocho principios clave que debes conocer:

1. Nombres Significativos: Los nombres deben describir claramente lo que hace una variable, función o clase.

Ejemplo: En lugar de x, usa userAge si representa la edad de un usuario, y en lugar de calculate, escribe lo que calcula la función.

   // Malo
   function calculate(x: number): number {
       return x * 12;
   }

   // Bueno
   function calculateUserAgeInMonths(userAge: number): number {
       return userAge * 12;
   }

2. Regla del Boy Scout: Deja el código mejor de lo que lo encontraste. Refactoriza y mejora a medida que avanzas.

Ejemplo: Si corriges un error y ves código desordenado, límpialo antes de hacer el commit.

   // Antes
   function fetchUserData(userId: string): any {
       const data = getDataFromDatabase(userId);
       return data;
   }

   // Después
   function fetchUserData(userId: string): User {
       return getDataFromDatabase(userId).user;
   }

3. Reducir el Acoplamiento: Minimiza las dependencias entre clases para hacer tu base de código más modular.

Ejemplo: Usa inyección de dependencias en lugar de codificar las dependencias directamente.

   // Malo
   class UserService {
       private database: Database;

       constructor() {
           this.database = new Database();
       }
   }

   // Bueno
   class UserService {
       private database: Database;

       constructor(database: Database) {
           this.database = database;
       }
   }

4. Sé el Autor: Escribe código como si contaras una historia. Las funciones deben ser pequeñas y enfocadas.

Ejemplo: Piensa en ello como hacer un batido. En lugar de una función gigante que elige frutas, mezcla y sirve, divídela en funciones más pequeñas y enfocadas.

   // Antes
   function makeSmoothie(fruit: string, liquid: string): void {
       console.log(`Choosing ${fruit}`);
       console.log(`Blending ${fruit} with ${liquid}`);
       console.log(`Pouring the smoothie into a glass`);
   }

   // Después
   function chooseFruit(fruit: string): void {
       console.log(`Choosing ${fruit}`);
   }

   function blend(fruit: string, liquid: string): void {
       console.log(`Blending ${fruit} with ${liquid}`);
   }

   function pourIntoGlass(): void {
       console.log(`Pouring the smoothie into a glass`);
   }

   function makeSmoothie(fruit: string, liquid: string): void {
       chooseFruit(fruit);
       blend(fruit, liquid);
       pourIntoGlass();
   }

5. DRY (No te Repitas): Evita duplicar código creando componentes reutilizables.

Ejemplo: Crea una función auxiliar en lugar de copiar y pegar bloques de código.

   // Antes
   function makeDogSound(): string {
       return "The dog says: Woof!";
   }

   function makeCatSound(): string {
       return "The cat says: Meow!";
   }

    // Después
    function makeAnimalSound(animal: string, sound: string): string {
       return `The ${animal} says: ${sound}!`;
    }

    function makeDogSound(): string {
        return makeAnimalSound("dog", "Woof");
    }

    function makeCatSound(): string {
       return makeAnimalSound("cat", "Meow");
    }

6. Comentarios: Comenta solo cuando sea necesario y evita explicaciones obvias.

Ejemplo: En lugar de // Increase salary by 10%, nombra tu función increaseSalaryByPercentage(10).

   // Antes
   function increaseSalary(employee: Employee): void {
       // Increase salary by 10%
       employee.salary *= 1.10;
   }

   // Después
   function increaseSalaryByPercentage(employee: Employee, percentage: number): void {
       employee.salary *= (1 + percentage / 100);
   }

7. Manejo de Errores: Maneja los errores de manera clara e inmediata, con mensajes específicos.

Ejemplo: Si un archivo no se puede abrir, lanza una excepción con un mensaje sobre la ruta del archivo y el error.

   // Antes
   function readFile(filePath: string): string {
       const file = fs.readFileSync(filePath, 'utf8');
       return file;
   }

   // Después
   function readFile(filePath: string): string {
       try {
           return fs.readFileSync(filePath, 'utf8');
       } catch (e) {
           throw new Error(`Failed to open file ${filePath}: ${e.message}`);
       }
   }

8. Pruebas Limpias: Asegúrate de que tus pruebas sean rápidas, independientes, repetibles, auto-validables y oportunas.

Ejemplo: Escribe pruebas unitarias que se concentren en un aspecto de la funcionalidad a la vez.

   // Ejemplo de prueba para una función
   describe('calculateCircleArea', () => {
       it('should correctly calculate the area of a circle', () => {
           expect(calculateCircleArea(5)).toBeCloseTo(78.54);
       });
   });

   describe('calculateCylinderArea', () => {
       it('should correctly calculate the area of a cylinder', () => {
           expect(calculateCylinderArea(5, 10)).toBeCloseTo(471.23);
       });
   });

¿Qué son las "Mejores Prácticas"? 🛠️

Las "Mejores Prácticas" son métodos y técnicas probados para mejorar diversos aspectos del desarrollo de software. Aquí hay seis ejemplos clave que también deberías conocer:

1. Pruebas de Código: Prueba tu código regularmente para detectar errores temprano.

Ejemplo: Usa herramientas como Jest para JavaScript o JUnit para Java para automatizar tus pruebas.

2. Legibilidad: Escribe código que sea fácil de leer y entender.

Ejemplo: Usa convenciones de nombres consistentes y una clara indentación.

3. Arquitectura: Diseña tu software con una estructura clara.

Ejemplo: Aplica patrones como MVC (Modelo-Vista-Controlador) para separar preocupaciones.

4. Patrones de Diseño: Usa patrones establecidos para resolver problemas comunes.

Ejemplo: El patrón Singleton asegura que una clase tenga solo una instancia, lo que lo hace ideal para mantener una conexión de base de datos única y eficiente en toda la aplicación. Te dejo un ejemplo en caso de que tengas curiosidad sobre este patrón.

   import { Client } from 'pg'; // Ejemplo con PostgreSQL

   class DatabaseConnection {
       private static instance: DatabaseConnection;
       private client: Client;

       // Constructor privado para evitar instanciación directa
       private constructor() {
           this.client = new Client({
               connectionString: process.env.DATABASE_URL,
           });
           this.client.connect();
       }

       // Método estático para obtener la única instancia de la clase
       public static getInstance(): DatabaseConnection {
           if (!DatabaseConnection.instance) {
               // Crear la instancia si no existe
               DatabaseConnection.instance = new DatabaseConnection();
           }
           return DatabaseConnection.instance;
       }

       public async query(text: string, params?: any[]): Promise<any> {
           return this.client.query(text, params);
       }
   }

   // Ejemplo de uso de la conexión a base de datos singleton
   const db = DatabaseConnection.getInstance(); // Obtener la única instancia de la conexión a base de datos
   db.query('SELECT * FROM users WHERE id = $1', [1])
       .then(res => console.log(res.rows))
       .catch(err => console.error('Database query error:', err));

5. Sistemas de Control de Versiones (VCS): Gestiona los cambios de código con herramientas como Git.

Ejemplo: Sigue los principios ACID para commits: Atomicidad, Consistencia, Aislamiento y Durabilidad.

6. DRY y KISS: Aplica Don’t Repeat Yourself (DRY) y Keep It Simple and Stupid (KISS).

Ejemplo: Simplifica funciones complejas y evita el código redundante.

Diferencias Clave 🔍

Alcance: "Clean Code" se enfoca en escribir código limpio y mantenible. En contraste, las "Mej

ores Prácticas" abarcan una gama más amplia de técnicas y estrategias para diversos aspectos del desarrollo de software.

Aplicación: "Clean Code" proporciona directrices específicas para mejorar la calidad del código, mientras que las "Mejores Prácticas" ofrecen un enfoque más integral para mejorar la efectividad general del proyecto.

Conclusión 🎯

"Clean Code" es una parte crucial de las Mejores Prácticas, enfocándose en crear código legible y mantenible. Las Mejores Prácticas, por otro lado, abarcan una amplia gama de técnicas para mejorar diferentes aspectos del desarrollo de software. Usar ambos puede mejorar significativamente la calidad y eficiencia de tus proyectos.

¿Cuáles son tus mejores prácticas favoritas para escribir código limpio y gestionar proyectos? Comparte tus consejos y experiencias a continuación—¡ayudémonos mutuamente a evitar esos "dolores de cabeza" y "WTFs" en nuestros viajes de desarrollo! 💬

Clean Code vs Best Practices: What’s the Difference?

The Eagle 🦅 — Sun, 08 Sep 2024 11:55:40 +0000

In software development, "Clean Code" and "Best Practices" are two important concepts. Sometimes you might hear comments like "Good job buddy, your code looks clean" or "Apply best practices to avoid technical debt next time bro." Although they overlap, they each play unique roles in creating high-quality, maintainable software. Let’s break down what each term means, explore some illustrative examples, and see how they differ.

What is "Clean Code"? 📚

"Clean Code" is a book by Robert C. Martin (Uncle Bob) that provides guidelines for writing code that's easy to read, understand, and maintain. Here are eight key principles that you should know:

1. Meaningful Names: Names should clearly describe what a variable, function, or class does.

Example: Instead of x, use userAge if it represents a user’s age, and instead of calculate, write what the function calculates.

   // Bad
   function calculate(x: number): number {
       return x * 12;
   }

   // Good
   function calculateUserAgeInMonths(userAge: number): number {
       return userAge * 12;
   }

2. Boy Scout Rule: Leave the code better than you found it. Refactor and improve as you go.

Example: If you fix a bug and see messy code, clean it up before committing changes.

   // Before
   function fetchUserData(userId: string): any {
       const data = getDataFromDatabase(userId);
       return data;
   }

   // After
   function fetchUserData(userId: string): User {
       return getDataFromDatabase(userId).user;
   }

3. Reduce Coupling: Minimize dependencies between classes to make your codebase more modular.

Example: Use dependency injection instead of hard-coding dependencies.

   // Bad
   class UserService {
       private database: Database;

       constructor() {
           this.database = new Database();
       }
   }

   // Good
   class UserService {
       private database: Database;

       constructor(database: Database) {
           this.database = database;
       }
   }

4. Be the Author: Write code as if telling a story. Functions should be small and focused.

Example: Think of it like making a smoothie. Instead of one giant function that picks fruit, blends, and pours, split it into smaller, focused functions.

   // Before
   function makeSmoothie(fruit: string, liquid: string): void {
       console.log(`Choosing ${fruit}`);
       console.log(`Blending ${fruit} with ${liquid}`);
       console.log(`Pouring the smoothie into a glass`);
   }

   // After
   function chooseFruit(fruit: string): void {
       console.log(`Choosing ${fruit}`);
   }

   function blend(fruit: string, liquid: string): void {
       console.log(`Blending ${fruit} with ${liquid}`);
   }

   function pourIntoGlass(): void {
       console.log(`Pouring the smoothie into a glass`);
   }

   function makeSmoothie(fruit: string, liquid: string): void {
       chooseFruit(fruit);
       blend(fruit, liquid);
       pourIntoGlass();
   }

5. DRY (Don’t Repeat Yourself): Avoid duplicating code by creating reusable components.

Example: Create a helper function instead of copying and pasting code blocks.

   // Before
   function makeDogSound(): string {
       return "The dog says: Woof!";
   }

   function makeCatSound(): string {
       return "The cat says: Meow!";
   }

    // After
    function makeAnimalSound(animal: string, sound: string): string {
       return `The ${animal} says: ${sound}!`;
    }

    function makeDogSound(): string {
        return makeAnimalSound("dog", "Woof");
    }

    function makeCatSound(): string {
       return makeAnimalSound("cat", "Meow");
    }

6. Commenting: Comment only when necessary and avoid obvious explanations.

Example: Instead of // Increase salary by 10%, name your function increaseSalaryByPercentage(10).

   // Before
   function increaseSalary(employee: Employee): void {
       // Increase salary by 10%
       employee.salary *= 1.10;
   }

   // After
   function increaseSalaryByPercentage(employee: Employee, percentage: number): void {
       employee.salary *= (1 + percentage / 100);
   }

7. Error Handling: Handle errors clearly and immediately, with specific messages.

Example: If a file can’t be opened, throw an exception with a message about the file path and error.

   // Before
   function readFile(filePath: string): string {
       const file = fs.readFileSync(filePath, 'utf8');
       return file;
   }

   // After
   function readFile(filePath: string): string {
       try {
           return fs.readFileSync(filePath, 'utf8');
       } catch (e) {
           throw new Error(`Failed to open file ${filePath}: ${e.message}`);
       }
   }

8. Clean Testing: Ensure your tests are fast, independent, repeatable, self-validating, and timely.

Example: Write unit tests that focus on one aspect of functionality at a time.

   // Test example for a function
   describe('calculateCircleArea', () => {
       it('should correctly calculate the area of a circle', () => {
           expect(calculateCircleArea(5)).toBeCloseTo(78.54);
       });
   });

   describe('calculateCylinderArea', () => {
       it('should correctly calculate the area of a cylinder', () => {
           expect(calculateCylinderArea(5, 10)).toBeCloseTo(471.23);
       });
   });

What are "Best Practices"? 🛠️

"Best Practices" are proven methods and techniques to improve various aspects of software development. Here are six key examples that you should also know:

1. Code Testing: Regularly test your code to catch bugs early.

Example: Use tools like Jest for JavaScript or JUnit for Java to automate your tests.

2. Readability: Write code that is easy to read and understand.

Example: Use consistent naming conventions and clear indentation.

3. Architecture: Design your software with a clear structure.

Example: Apply patterns like MVC (Model-View-Controller) to separate concerns.

4. Design Patterns: Use established patterns to solve common problems.

Example: The Singleton pattern ensures a class has only one instance, making it ideal for maintaining a single, efficient database connection throughout the application. I'll leave an example in case you're curious about this pattern.

   import { Client } from 'pg'; // Example with PostgreSQL

   class DatabaseConnection {
       private static instance: DatabaseConnection;
       private client: Client;

       // Private constructor to prevent direct instantiation
       private constructor() {
           this.client = new Client({
               connectionString: process.env.DATABASE_URL,
           });
           this.client.connect();
       }

       // Static method to get the single instance of the class
       public static getInstance(): DatabaseConnection {
           if (!DatabaseConnection.instance) {
               // Create instance if it does not exist
               DatabaseConnection.instance = new DatabaseConnection();
           }
           // Return the single instance if it does exist
           return DatabaseConnection.instance;
       }

       public async query(text: string, params?: any[]): Promise<any> {
           return this.client.query(text, params);
       }
   }

   // Usage example of the singleton database connection
   const db = DatabaseConnection.getInstance(); // Get the single instance of the database connection
   db.query('SELECT * FROM users WHERE id = $1', [1])
       .then(res => console.log(res.rows))
       .catch(err => console.error('Database query error:', err));

5. Version Control Systems (VCS): Manage code changes with tools like Git.

Example: Follow ACID principles for commits: Atomicity, Consistency, Isolation, and Durability.

6. DRY and KISS: Apply Don’t Repeat Yourself (DRY) and Keep It Simple and Stupid (KISS) principles.

Example: Simplify complex functions and avoid redundant code.

Key Differences 🔍

Scope: "Clean Code" focuses on writing clean, maintainable code. In contrast, "Best Practices" encompass a broader range of techniques and strategies for various aspects of software development.
Application: "Clean Code" provides specific guidelines for improving code quality, while "Best Practices" offers a more comprehensive approach to enhancing overall project effectiveness.

Conclusion 🎯

"Clean Code" is a crucial part of Best Practices, focusing on creating readable and maintainable code. Best Practices, on the other hand, encompass a wide range of techniques for improving different aspects of software development. Using both can significantly enhance the quality and efficiency of your projects.

What are your favorite best practices for writing clean code and managing projects? Share your tips and experiences below—let’s help each other avoid those "painful headaches" and "WTFs" in our development journeys! 💬

Encontrando Tu Propio Camino

The Eagle 🦅 — Thu, 29 Aug 2024 10:58:31 +0000

Érase una vez en un bosque vibrante 🌳, una joven cierva llamada Liora se encontraba preocupada por una serie de desafíos que no podía superar 😔. En busca de sabiduría, decidió consultar a las criaturas más formidables que conocía: el tigre 🐅, el águila 🦅 y el pez 🐟.

La Valentía del Tigre

Primero, Liora se acercó al tigre, un símbolo de fuerza y coraje 💪🦁.

"Tigre poderoso," comenzó, "¿cómo puedo superar estos obstáculos que se interponen en mi camino?" 🤔

El tigre, con su mirada penetrante 👁️, respondió:

"Puedo mostrarte el poder de la valentía y la fuerza." 💥

Liora intentó imitar la valentía del tigre, enfrentando sus desafíos con feroz determinación 💪. Pero, por más que lo intentaba, no podía superarlos. Frustrada 😤, regresó al tigre y preguntó:

"¿Por qué fallé al seguir tu consejo?" 🤷‍♀️

El tigre respondió con calma:

"Porque, Liora, mi fuerza nace de una vida de batallas en la jungla 🌿. Tu fuerza viene de tu corazón ❤️, no de tus garras. Mi camino nunca fue hecho para ti."

La Perspectiva del Águila

Luego, Liora subió al alto posadero del águila 🦅.

"Gran águila, ¿cómo puedo elevarme por encima de mis desafíos?" preguntó 🌄.

El águila, volando alto, respondió:

"Puedo enseñarte a ver desde grandes alturas y ganar perspectiva." 👀

Liora intentó adoptar la perspectiva elevada del águila, tratando de ver sus desafíos desde la distancia 🌌. Pero, a pesar de sus esfuerzos, aún no podía encontrar una solución. Regresó al águila, desconcertada 😕.

"¿Por qué fallé al intentar ver como tú lo haces?" preguntó.

El águila respondió:

"Porque, Liora, yo veo el mundo desde el cielo ☁️, donde todo parece pequeño y distante. Pero tú vives en el suelo 🌍, donde cada detalle importa. Mi perspectiva no está hecha para ti."

La Adaptabilidad del Pez

Finalmente, Liora nadó hacia el pez que se deslizaba con gracia en el arroyo 🐟.

"Pez ágil, ¿cómo puedo navegar por estos problemas?" inquirió 🌊.

El pez, nadando sin esfuerzo, dijo:

"Puedo mostrarte el camino a través de las corrientes." 🌊

Liora intentó seguir el consejo del pez, moviéndose con el flujo de su entorno 🌊. Pero se encontró arrastrada, incapaz de navegar las corrientes como lo hacía el pez. Exhausta 😩, preguntó al pez:

"¿Por qué no pude tener éxito al seguir tu ejemplo?" 🤔

El pez respondió suavemente:

"Porque, Liora, nací en el agua 🌊, donde estoy en casa en las corrientes. Pero tú eres de la tierra 🌍, donde tus pasos guían tu camino. Mi forma de guiarte no puede atravesar tu propio mundo."

La Sabiduría de la Tortuga

Confundida y desalentada 😔, Liora vagó por el bosque 🌳, sintiéndose perdida e insegura. Entonces, conoció a una tortuga anciana 🐢 que había observado su búsqueda. La tortuga, sabia y constante, dijo:

"Liora, buscaste consejo del tigre 🐅, el águila 🦅 y el pez 🐟—cada uno notable a su manera. Pero debes recordar, no eres un tigre 🐅, un águila 🦅, o un pez 🐟. Eres una cierva 🦌, y solo tú puedes encontrar el camino que te conviene."

Inspirada por las palabras de la tortuga 🌟, Liora abrazó sus fortalezas únicas y comenzó a forjar su propio camino 🌈. Descubrió que, aunque la valentía del tigre 💪, la perspectiva del águila 👀, y la adaptabilidad del pez 🌊 eran valiosas, sus propias cualidades e instintos eran las claves para superar sus desafíos.

A partir de ese día, Liora enfrentó sus obstáculos con nueva confianza 🌟, sabiendo que la mejor guía provenía de su interior 💖.

Reflexión

Al igual que Liora, a menudo buscamos orientación en los demás—ya sea a través de libros 📚, mentores 👩‍🏫, familiares 👨‍👩‍👧‍👦, o incluso videos de YouTube 🎥. En el mundo tecnológico actual, encontramos innumerables caminos a seguir y esperamos que al seguirlos, encontraremos el éxito. Es importante intentar y experimentar con estos métodos cuando aún no tenemos el nuestro. La alternativa es no hacer nada y arrepentirse de las oportunidades que perdimos, lo cual es aún más desalentador. A través de este proceso, no solo obtenemos conocimientos sobre el mundo 🌍, sino también aprendemos sobre nosotros mismos 🌟. Descubrimos nuestras propias fortalezas 💪, debilidades 😔, y el camino único que mejor nos conviene. En última instancia, el viaje de intentar y, a veces, fallar, nos ayuda a descubrir nuestro verdadero ser y a desarrollar nuestros propios métodos para el éxito, enseñándonos que las respuestas más significativas provienen de nuestro interior 💖.

Conclusión

No tengas miedo de intentar y fallar 💪; ten miedo de no intentar en absoluto y de nunca descubrir quién eres o de qué eres realmente capaz 🌟.

Si encontraste esto útil, siéntete libre de dejar un comentario o una reacción. ¡Gracias! 😊

Finding Your Own Path

The Eagle 🦅 — Thu, 29 Aug 2024 10:53:52 +0000

Once upon a time in a vibrant forest 🌳, a young deer named Liora found herself troubled by a series of challenges she couldn't overcome 😔. Seeking wisdom, she decided to consult the most formidable creatures she knew: the tiger 🐅, the eagle 🦅, and the fish 🐟.

The Tiger's Courage

First, Liora approached the tiger, a symbol of strength and courage 💪🦁.

"Mighty tiger," she began, "how can I overcome these obstacles that stand in my way?" 🤔

The tiger, with its piercing gaze 👁️, replied:

"I can show you the power of bravery and might." 💥

Liora tried to mimic the tiger’s bravery, confronting her challenges with fierce determination 💪. But no matter how hard she tried, she couldn’t overcome them. Frustrated 😤, she returned to the tiger and asked:

"Why did I fail when I followed your advice?" 🤷‍♀️

The tiger calmly responded:

"Because, Liora, my strength is born from a lifetime of battles in the jungle 🌿. Your strength comes from your heart ❤️, not your claws. My way was never meant for you."

The Eagle's Perspective

Next, Liora went up to the eagle’s lofty perch 🦅.

"Great eagle, how do I rise above my challenges?" she asked. 🌄

The eagle, soaring high, answered:

"I can teach you to see from great heights and gain perspective." 👀

Liora attempted to adopt the eagle’s lofty perspective, trying to view her challenges from a distance 🌌. But despite her efforts, she still couldn’t find a solution. She returned to the eagle, perplexed 😕.

"Why did I fail when I tried to see as you do?" she asked.

The eagle replied:

"Because, Liora, I see the world from the sky ☁️, where everything appears small and distant. But you live on the ground 🌍, where each detail matters. My perspective is not meant to be yours."

The Fish's Adaptability

Finally, Liora swam to the fish gliding gracefully in the stream 🐟.

"Swift fish, how can I navigate these troubles?" she inquired. 🌊

The fish, swimming effortlessly, said:

"I can show you the way through the currents." 🌊

Liora tried to follow the fish’s advice, moving with the flow of her surroundings 🌊. But she found herself swept away, unable to navigate the currents as the fish did. Exhausted 😩, she asked the fish:

"Why couldn’t I succeed by following your example?" 🤔

The fish answered gently:

"Because, Liora, I was born in the water 🌊, where I am at home in the currents. But you are of the land 🌍, where your steps guide your path. My way cannot guide you through your own world."

The Tortoise's Wisdom

Confused and disheartened 😔, Liora wandered through the forest 🌳, feeling lost and unsure. Then, she met an old tortoise 🐢 who had observed her quest. The tortoise, wise and steady, said:

"Liora, you sought advice from the tiger 🐅, the eagle 🦅, and the fish 🐟—each remarkable in their own right. But you must remember, you are not a tiger 🐅, an eagle 🦅, or a fish 🐟. You are a deer 🦌, and only you can find the path that suits you."

Inspired by the tortoise's words 🌟, Liora embraced her unique strengths and began to forge her own path 🌈. She discovered that while the tiger’s courage 💪, the eagle’s perspective 👀, and the fish’s adaptability 🌊 were valuable, her own qualities and instincts were the keys to overcoming her challenges.

From that day on, Liora faced her obstacles with newfound confidence 🌟, knowing that the best guidance came from within 💖.

Reflection

Just like Liora, we often seek guidance from others—whether it’s through books 📚, mentors 👩‍🏫, family 👨‍👩‍👧‍👦, or even YouTube videos 🎥. In today’s tech-driven world, we encounter countless paths to follow and hope that by pursuing them, we will find success. It’s important to try and experiment with these methods when we don’t have our own yet. The alternative is to do nothing and regret the opportunities we missed, which is even more disheartening. Through this process, we not only gain insights about the world 🌍 but also learn about ourselves 🌟. We discover our own strengths 💪, weaknesses 😔, and the unique path that suits us best. Ultimately, the journey of trying, and sometimes failing, helps us discover our true selves and develop our own methods for success, teaching us that the most meaningful answers come from within 💖.

Conclusion

Don’t be afraid to try and fail 💪; be afraid of never trying at all and never discovering who you are or what you’re truly capable of 🌟.

If you found this helpful, feel free to leave a comment or reaction. Thank you! 😊

Si Ya No Sientes Pasión por la Programación, Quizás Nunca Haya Existido

The Eagle 🦅 — Mon, 05 Aug 2024 12:11:03 +0000

Cambridge define la pasión como un interés extremo en o deseo de hacer algo.

Pero permíteme preguntarte DE NUEVO: ¿por qué tendrías un INTERÉS EXTREMO en o deseo de HACER algo? La respuesta es simple. Es porque te brinda algún tipo de beneficio. Y estos beneficios pueden ser cualquier cosa que imaginemos o hayamos experimentado, tales como:

Sentirse aliviado después de resolver un problema
Volverse más inteligente o fuerte
Obtener nuevos conocimientos
Aumentar tu confianza
Tener proyectos para mostrar tus habilidades
Ascender en tu campo o trabajo
Encontrar un empleo

A medida que envejeces o logras estos objetivos, los beneficios que buscas pueden cambiar:

Adquirir bienes materiales
Planear futuras vacaciones
Acceder a una mejor atención médica
Pagar deudas
Trabajar desde casa
Mejorar tu calidad de vida
Simplemente estar empleado
Prepararte para la jubilación
Empezar tu propio negocio

Todos tenemos sueños y expectativas diferentes. Pero recuerda, tu pasión por la programación estaba impulsada por los beneficios que obtenías. Está perfectamente bien encontrar una nueva pasión. Mira a Zuckerberg: es una persona diferente ahora. Pasó de ser visto como un "reptiliano androide" motivado por el lucro, y que vendía una versión del metaverso que parecia de Wii a alguien que ahora está regalando modelos de IA por valor de $10 mil millones para código abierto y medallista de oro en un torneo de BJJ. Ahora es más feliz y humano que nunca. Al igual que él, necesitas encontrar nuevos beneficios en cosas que puedan convertirse en lo que llamamos "pasión", pero primero debes soportar un período de lucha.

Entonces, si notas que los CEOs y gerentes trabajan sin parar y te ven raro cuando no estás tan entusiasta a su mismo nivel, es porque ellos están obteniendo o van a obtener enormes beneficios. Esto no es pasión; de lo contrario, darían todo el dinero a sus empleados y trabajarían gratis. Para ser justos con ellos, pagaron el costo para estar allí, así como tú lo estás haciendo para tu propia carrera, que es esfuerzo y tiempo.

Todos somos únicos. Algunas personas están bien con ciertos trabajos mientras que otras no lo están. Si te sientes infeliz o desmotivado, podría ser porque tus beneficios ya no están alineados con donde estás, y no estás dispuesto a pagar el costo de donde quieres estar.

¿Qué debería hacer?

Cuando un cliente está insatisfecho con un servicio, busca un nuevo lugar. Piensa en tu carrera de la misma manera: podría ser el momento de un ascenso, un aumento, un nuevo trabajo, un nuevo proyecto, una nueva cultura o un nuevo pasatiempo fuera del trabajo. Tal vez necesites una aventura más grande. Siempre busca el próximo desafío, pero ten en cuenta que hay un costo involucrado. No tengas miedo de pagarlo, pero asegúrate de estar en una posición para permitirlo.

P.D.:

Y si encuentras que te falta pasión en la vida, podría ser debido a la sobreestimulación. La solución es sencilla: da un paso atrás y elimina lo que te está sobreestimulado. No luches contra ello. Como runner y hiker, te puedo decir que alejarse requiere más inteligencia y esfuerzo. Sé inteligente con tus batallas; usa esa energía para hacer un plan que te ayude a llegar a donde quieres estar, pero siempre recuerda que hay un precio que pagar por ese beneficio, y esa es la parte divertida.

If You No Longer Feel Passion for Programming, It Might Never Have Existed

The Eagle 🦅 — Mon, 05 Aug 2024 12:02:52 +0000

This is a very hot take, just like my man ThePrimeagen would say. So, let’s dive into it: what is passion?

Cambridge defines passion as an extreme interest in or wish for doing something.

But let me ask you AGAIN: why would you have an EXTREME interest in or wish for DOING something? The answer is simple. It’s because it brings you some kind of benefit. And these benefits can be anything we imagine or have experienced, such as:

Feeling relieved after solving a problem
Becoming smarter or stronger
Gaining new knowledge
Boosting your confidence
Having projects to showcase your skills
Rising to the top in your field or job
Finding a job

As you grow older or achieve these goals, the benefits you seek might shift:

Acquiring material things
Planning future vacations
Accessing better healthcare
Paying off debts
Working from home
Improving your quality of life
Just being employed
Preparing for retirement
Starting your own business

We all have different dreams and expectations. But remember, your passion for programming was driven by the benefits you gained. It’s perfectly okay to find a new passion. Look at Zuckerberg—he’s a different person now. He went from being seen as a profit-driven "robot lizard" selling a Wii version of the metaverse to someone who’s now giving away $10 billion worth of AI models for open source and BJJ gold medalist in a tournament. Now he's happier and more human than ever. Like him, you need to find new benefits in things that may later become the thing we call "passion", but you have to endure a period of struggle first.

So, if you notice CEOs and managers who work non-stop and seem baffled that you’re not as enthusiastic, it’s because they’re getting or are going to get huge benefits. This is not passion; otherwise, they'd give all the money to their employees and work for free. To be fair to them, they paid the cost to be there, just as you are doing for your own career, which is effort and time.

Everyone is unique. Some people are okay with certain jobs while others aren't. If you’re feeling unhappy or unmotivated, it might be because your benefits are no longer aligning with where you are, and you’re not willing to pay the cost of where you want to be.

What should I do?

When a customer is unhappy with a service, they look for a new place. Think of your career in the same way: it might be time for a promotion, a raise, a new job, new project, new culture or a new hobby outside of work. Maybe you need something more adventurous. Always seek the next challenge, but be aware that there’s a cost involved. Don’t be afraid to pay it, but make sure you’re in a position to afford it.

P.S.:

And if you find you’re lacking passion in life, it could be due to overstimulation. The fix is straightforward: take a step back and remove what’s overstimulating you. Don’t fight it. As a runner and hiker, I can tell you that stepping away takes more brains and effort. Be smart about your battles; use that energy to make a plan that helps you get to where you want to be, but always remember that there is a price to pay for that benefit, and that's the fun part.

🚀 Guía para principiantes: instalación y uso de GitHub CLI 🛠️

The Eagle 🦅 — Tue, 30 Jul 2024 12:11:46 +0000

¿Por qué usar GitHub CLI?

GitHub CLI lleva GitHub a tu terminal. Te permite clonar, crear, bifurcar y ver repositorios, así como manejar issues y pull requests con comandos para listar, crear, ver y fusionar estos. También puedes gestionar gists, activar y revisar los workflows de GitHub Actions, y hacer solicitudes directas a la API. Además, tienes opciones de autenticación y configuración disponibles para gestionar el acceso y los settings, mientras que las funcionalidades de búsqueda te ayudan a encontrar repositorios, issues y más.

Parte 1: Instalar GitHub CLI 🔨

macOS 🍎

gh está disponible a través de Homebrew, MacPorts, Conda, Spack, Webi, y como un binario descargable que incluye el instalador para Mac OS .pkg desde la página de lanzamientos.

# Homebrew
brew install gh

# MacPorts
sudo port install gh

# Conda
conda install gh --channel conda-forge

# Spack
spack install gh

# Webi
curl -sS https://webi.sh/gh | sh

Windows 🪟

gh está disponible a través de WinGet, scoop, Chocolatey, Conda, Webi, y como instalador MSI.

# WinGet
winget install --id GitHub.cli

# scoop
scoop install gh

# Chocolatey
choco install gh

# Conda
conda install gh --channel conda-forge

# Spack
spack install gh

# Webi
curl -sS https://webi.sh/gh | sh

Linux 🐧

Aquí realmente depende de lo que estés usando; puedes leer la documentación de instalación para Linux para encontrar lo que necesitas, o verificar aquí los comandos dependiendo de la distribución que estés usando.

# Arch
sudo pacman -S github-cli

# Debian, Ubuntu Linux, Raspberry Pi OS (apt)
(type -p wget >/dev/null || (sudo apt update && sudo apt-get install wget -y)) \
&& sudo mkdir -p -m 755 /etc/apt/keyrings \
&& wget -qO- https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null \
&& sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
&& echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
&& sudo apt update \
&& sudo apt install gh -y
# Actualizar
sudo apt update
sudo apt install gh

# Fedora, CentOS, Red Hat Enterprise Linux (dnf)
sudo dnf install 'dnf-command(config-manager)'
sudo dnf config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo
sudo dnf install gh --repo gh-cli
# Alternativamente, instalar desde el repositorio comunitario:
sudo dnf install gh
# Actualizar
sudo dnf update gh

# openSUSE/SUSE Linux (zypper)
sudo zypper addrepo https://cli.github.com/packages/rpm/gh-cli.repo
sudo zypper ref
sudo zypper install gh
# Actualizar
sudo zypper ref
sudo zypper update gh

Parte 2: Iniciar sesión 🔐

Primero escribe en tu terminal:

gh auth login

Te pedirá:

? ¿En qué cuenta deseas iniciar sesión?  [Usa las flechas para moverte, escribe para filtrar]
> GitHub.com
  GitHub Enterprise Server

Si eliges GitHub.com, te pedirá:

? ¿Cuál es tu protocolo preferido para las operaciones de Git en este host?  [Usa las flechas para moverte, escribe para filtrar]
> HTTPS
  SSH

A continuación, te preguntará tu protocolo y preferencia personal. Recomiendo SSH.

? ¿Cuál es tu protocolo preferido para las operaciones de Git en este host?  [Usa las flechas para moverte, escribe para filtrar]
  HTTPS
> SSH

Ahora solo crea la contraseña para tu clave SSH, el título y selecciona cómo te gustaría autenticarte, y si es la primera vez, solo usa Iniciar sesión con un navegador web.

? ¿Generar una nueva clave SSH para agregar a tu cuenta de GitHub? (Y/n) Y

 Ingresa una frase de contraseña para tu nueva clave SSH (Opcional): **************************

? Título para tu clave SSH: (GitHub CLI) TheMachine-Desktop

? ¿Cómo te gustaría autenticar GitHub CLI?  [Usa las flechas para moverte, escribe para filtrar]
> Iniciar sesión con un navegador web
  Pegar un token de autenticación

! Primero copia tu código de un solo uso: 1234-ABCD
Presiona Enter para abrir github.com en tu navegador...

🎉 ¡Felicidades! 🎉, ahora puedes usar GitHub desde tu terminal 🖥️. Si escribes gh auth status, deberías obtener algo como esto:

$ gh auth status
github.com
  ✓ Conectado a la cuenta github.com nombredeusuario (/home/username/.config/gh/hosts.yml)
  - Cuenta activa: true
  - Protocolo de operaciones de Git: ssh
  - Token: ...
  - Ámbitos del token: ....

Parte 3: Comandos útiles 📝

Aquí te daré ⭐Mis 5 comandos principales en GitHub CLI🏅 para que te hagas una idea de lo que eres capaz de hacer, pero siéntete libre de revisar la documentación para obtener un conocimiento más profundo de esta herramienta.

1 - Clonar un repositorio de GitHub 🥇: gh repo clone owner/repo

gh repo clone chrislgarry/Apollo-11

Bonus 🎁:
Como estás usando ssh, también puedes ir a esta sección de un repositorio de GitHub:

Y git clone de esta manera:

git clone git@github.com:chrislgarry/Apollo-11.git

Y puedes ver el README.md del repositorio:

 gh repo view chrislgarry/Apollo-11

2 - Crear un nuevo repositorio en GitHub 🥈: gh repo create repo, puedes usar opciones como --public, private, --description <string> y más.

gh repo create my-new-repo --public

3 - Crear un nuevo gist 🥉: gh gist create <file>

gh gist create file.txt

Bonus 🎁:
También puedes listar los gists:

gh gist list

4 - Crear un nuevo issue 🏅: gh issue create --title <title> --body <body>

gh issue create --title "Título del issue" --body "Cuerpo del issue"

Bonus 🎁:
También puedes crear issues:

gh issue create --title "Título del issue" --body "

Cuerpo del issue"

ver issues:

gh issue view <número-del-issue>

Y cerrar issues:

gh issue close <número-del-issue>

5 - Listar pull requests 🌟: gh pr list

gh pr list

Bonus 🎁:
También puedes ver la pull request:

gh pr view <número-del-pr>

fusionar una pull request:

gh pr merge <número-del-pr>

Y revisarla:

gh pr review --approve --body "¡Se ve bien!"

Pensamientos finales 🎉

GitHub CLI lleva GitHub a tu terminal, ¡haciendo que sea increíblemente poderoso! 🚀 Espero que hayas encontrado útil este post y que te haya inspirado a sacar el máximo provecho de esta herramienta. ¡No olvides suscribirte para recibir más actualizaciones de mis futuros posts! 🙌🖥️

Fuentes 📚

Instalar GitHub CLI
Instalar GitHub CLI en Linux
Manual de GitHub CLI
Código de Apollo 11

Aquí me gustaría agregar una frase personal, pero todavía estoy pensando/buscando una 😂

🚀 Begginer's Guide: installing and using GitHub CLI 🛠️

The Eagle 🦅 — Tue, 30 Jul 2024 11:56:19 +0000

Why use GitHub CLI?

GitHub CLI brings GitHub to your terminal. It allows you to clone, create, fork, and view repositories, as well as handle issues and pull requests with commands to list, create, view, and merge them. You can also manage gists, trigger and review GitHub Actions workflows, and make direct API requests. You also have authentication and configuration options are available to manage access and settings, while search functionalities help you find repositories, issues, and more.

Part 1: Install GithubCLI 🔨

macOS 🍎

gh is available via Homebrew, MacPorts, Conda, Spack, Webi, and as a downloadable binary including Mac OS installer .pkg from the releases page.



# Homebrew
brew install gh

# MacPorts
sudo port install gh

# Conda
conda install gh --channel conda-forge

# Spack
spack install gh

# Webi
curl -sS https://webi.sh/gh | sh

Windows 🪟

gh is available via WinGet, scoop, Chocolatey, Conda, Webi, and as MSI installer.



# WinGet
winget install --id GitHub.cli

# scoop
scoop install gh

# Chocolatey
choco install gh

# Conda
conda install gh --channel conda-forge

# Spack
spack install gh

# Webi
curl -sS https://webi.sh/gh | sh

Linux 🐧

Here it really depends what you're using, here can you read the linux install documentation to find what you need, or check here the commands depending the distro you're using.



# Arch
sudo pacman -S github-cli

# Debian, Ubuntu Linux, Raspberry Pi OS (apt)
(type -p wget >/dev/null || (sudo apt update && sudo apt-get install wget -y)) \
&& sudo mkdir -p -m 755 /etc/apt/keyrings \
&& wget -qO- https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null \
&& sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
&& echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
&& sudo apt update \
&& sudo apt install gh -y
# Upgrade
sudo apt update
sudo apt install gh

# Fedora, CentOS, Red Hat Enterprise Linux (dnf)
sudo dnf install 'dnf-command(config-manager)'
sudo dnf config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo
sudo dnf install gh --repo gh-cli
#Alternatively, install from the community repository:
sudo dnf install gh
#Upgrade
sudo dnf update gh

# openSUSE/SUSE Linux (zypper)
sudo zypper addrepo https://cli.github.com/packages/rpm/gh-cli.repo
sudo zypper ref
sudo zypper install gh
# Upgrade
sudo zypper ref
sudo zypper update gh

Part 2: Log in 🔐

First write in your terminal:



gh auth login

Here will ask you:



? What account do you want to log into?  [Use arrows to move, type to filter]
> GitHub.com
  GitHub Enterprise Server

If you choosed Github.com it will ask you:



? What is your preferred protocol for Git operations on this host?  [Use arrows to move, type to filter]
> HTTPS
  SSH

Next it'll ask you your protocol and personal preference I recommend SSH.



? What is your preferred protocol for Git operationInstall Github CLI in Linuxs on this host?  [Use arrows to move, type to filter]
  HTTPS
> SSH

Now just create the password for your SSH Key, the title and select how you'd like to autheticate, and if this is your first time just use Login with a web browser.



? Generate a new SSH key to add to your GitHub account? (Y/n) Y

 Enter a passphrase for your new SSH key (Optional): **************************

? Title for your SSH key: (GitHub CLI) TheMachine-Desktop

? How would you like to authenticate GitHub CLI?  [Use arrows to move, type to filter]
> Login with a web browser
  Paste an authentication token

! First copy your one-time code: 1234-ABCD
Press Enter to open github.com in your browser...

🎉 Congratulations 🎉, now you can use Github from your terminal 🖥️.! if you write gh auth status, you should get something like this:



$ gh auth status
github.com
  ✓ Logged in to github.com account username (/home/username/.config/gh/hosts.yml)
  - Active account: true
  - Git operations protocol: ssh
  - Token: ...
  - Token scopes: ....

Part 3: Useful commands 📝

Here I'll give you ⭐My TOP 5 commands in Github CLI🏅 so you can build an idea of what you are capable of doing, but feel free to checkout the documentation to gain a deeper knowledge of this tool.

1 - Clone a GitHub repository 🥇: gh repo clone owner/repo



gh repo clone chrislgarry/Apollo-11

Bonus 🎁:
Since you're using ssh you can also go to this section of a GitHub repo:

And git clone it like this:



git clone git@github.com:chrislgarry/Apollo-11.git

And you can view the README.md of the repo:



 gh repo view chrislgarry/Apollo-11

2 - Create a new repository on GitHub 🥈: gh repo create repo, you can use flags like --public, private, --description <string> and more.



gh repo create my-new-repo --public

3 - Create a new gist 🥉: gh gist create <file>



gh gist create file.txt

Bonus 🎁:
You can also list them:



gh gist list

4 - Create a new issue 🏅: gh issue create --title <title> --body <body>



gh issue create --title "Issue title" --body "Issue body"

Bonus 🎁:
You can alse create issues:



gh issue create --title "Issue title" --body "Issue body"

view issues:



gh issue view <issue-number>

And close issues:



gh issue close <issue-number>

5 - List pull requests 🌟: gh pr list



gh pr list

Bonus 🎁:
You can also view the pull request:



gh pr view <pr-number>

merge a pull request:



gh pr merge <pr-number>

And review it:



gh pr review --approve --body "Looks good!"

Final Thoughts 🎉

GitHub CLI brings GitHub to your terminal, making it incredibly powerful! 🚀 I hope you found this post helpful and that it has inspired you to make the most of this tool. Don’t forget to subscribe for more updates for my future post! 🙌🖥️

Sources 📚

Install Github CLI
Install Github CLI in Linux
Github CLI manual
Apollo 11 Code

Here I'd like to add a personal phrase, but I'm still thinking/looking for one 😂

DEV Community: The Eagle 🦅

Manual de supervivencia Git de Ned 📚

Introducción

Índice 📋

Episodio 1: Primer Día de Trabajo y Errores

¿Qué puedo hacer para que no me regañen?

Consejo #1: Restaurar Archivos Salva Vidas

Oye, solo tengo un commit en mi proyecto, ¿puedo revertirlo?

Consejo #2: Usa git restore para Cambios No commiteados

Episodio 2: Tenemos una Nueva Prioridad, Houston

Voy a perder demasiado tiempo solo para ese cambio más adelante, ¿Qué puedo hacer?

Consejo #3: Guárdalo, Hermano

Episodio 3: ¡Crisis de CoolFeature!

Oh, hombre, necesito tiempo para esto y ellos lo necesitan ahora, ¿hay una forma más rápida?

Consejo #4: Usa Cherry-Pick para Obtener Ese Commit

Episodio 4: El Drama de "Cambié de Opinión"

Se ha ido para siempre, ahora voy a perder tiempo...

Consejo #5: Si No Lo Encuentras en git log, Es Hora de reflog

Conclusión 🎓

Ned's Declassified Git Survival Guide 📚

Introduction

Index 📋

Episode 1: First Day of Work & Bugs

What can I do so I don't get yelled at?

Advice #1: Restoring Files Saves Lives

Hey, I've only got one commit in my project, can I reverse that?

Advice #2: Use git restore for Uncommitted Changes

Episode 2: Hey, We've Got a New Priority, Houston

I'm Going to Spend Too Much Time Just for That Change Later On, What Can I Do?

Advice #3: Stash It, Bro

Episode 3: The CoolFeature Crisis!

Oh man, I need time for this and they need it now, is there a faster way?

Advice #4: Use Cherry-Pick to Get That Commit

Episode 4: The “I Changed My Mind” Drama

It's gone forever, now I'm going to waste time...

Advice #5: If You Can't Find It in git log, It's Time to reflog

Conclusion 🎓

Clean Code vs Mejores Prácticas: ¿Cuál es la Diferencia?

¿Qué es "Clean Code"? 📚

¿Qué son las "Mejores Prácticas"? 🛠️

Diferencias Clave 🔍

Conclusión 🎯

Clean Code vs Best Practices: What’s the Difference?

What is "Clean Code"? 📚

What are "Best Practices"? 🛠️

Key Differences 🔍

Conclusion 🎯

Encontrando Tu Propio Camino

La Valentía del Tigre

La Perspectiva del Águila

La Adaptabilidad del Pez

La Sabiduría de la Tortuga

Reflexión

Conclusión

Finding Your Own Path

The Tiger's Courage

The Eagle's Perspective

The Fish's Adaptability

The Tortoise's Wisdom

Reflection

Conclusion

Si Ya No Sientes Pasión por la Programación, Quizás Nunca Haya Existido

¿Qué debería hacer?

If You No Longer Feel Passion for Programming, It Might Never Have Existed

What should I do?

🚀 Guía para principiantes: instalación y uso de GitHub CLI 🛠️

¿Por qué usar GitHub CLI?

Parte 1: Instalar GitHub CLI 🔨

macOS 🍎

Windows 🪟

Linux 🐧

Parte 2: Iniciar sesión 🔐

Parte 3: Comandos útiles 📝

Pensamientos finales 🎉

Fuentes 📚

🚀 Begginer's Guide: installing and using GitHub CLI 🛠️

Why use GitHub CLI?

Part 1: Install GithubCLI 🔨

macOS 🍎

Windows 🪟

Consejo #2: Usa `git restore` para Cambios No commiteados

Consejo #5: Si No Lo Encuentras en `git log`, Es Hora de `reflog`

Advice #2: Use `git restore` for Uncommitted Changes

Advice #5: If You Can't Find It in `git log`, It's Time to `reflog`