¿Quién creéis que tiene más experiencia vital, una persona que ha afrontado muchas dificultades o una persona de la misma edad que haya tenido una vida fácil? ¿Quién será más competente?

Nosotros tenemos el control, la agencia de tomar el camino difícil o el fácil, pero lo más complicado es detectarlos y tener el valor, fuerza, convencimiento de tomarlo, porque es bueno para nosotros. ¿Qué tipo de persona quieres ser? ¿Tomarás la píldora roja o la píldora azul?

Every time I open a terminal on macOS, zsh takes like a second to show the prompt. It’s super annoying!

I profiled using

1
2
3
4
5
6
7
8
9

if [ -n "${ZSH_DEBUGRC+1}" ]; then
    zmodload zsh/zprof
fi

# your zsh config

if [ -n "${ZSH_DEBUGRC+1}" ]; then
    zprof
fi

To make it easier I’ve added this alias:

I’m diving headfirst into using uv in my daily grind to be more efficient in my pile of work. So, I’m throwing myself into all sorts of random scenarios.

On this journey, I’ve stumbled upon some [bugs][uv-bug] and nifty features like a super-powered cache. But, hold up! The real point of this post is how an innovation affects to the production process.

I’m sure you’ve found yourself needing to do quick calculations in the terminal. Sure, you could use a calculator app or a fancy spotlight bar, but sometimes the calculation is so simple that typing it directly would be easier. Wouldn’t it be nice if you could just type math "200 ** 2 / 200" and get your answer right away?

I’ve found an issue with uv while creating a simple venv. Nothing fancy with my dependencies. I’ve condensed everything in this issue:

• https://github.com/astral-sh/uv/issues/9413

But here is the minimal reproducible example of it:

1
2
3
4
5
6

rm -rf test
uv init test
cd test
uv version
# uv venv && uv pip install numpy statsforecast
uv add numpy statsforecast

For the time being, I’m using the latest release.

Hey there! 👋

This is a revisited version of my previous post about Makefiles, but this time I’m using uv (the shiny new Python package manager that’s faster than a caffeinated cheetah! 🐆).

I was tired of typing the same commands over and over in my Python projects, so I made this super cool Makefile using uv.

Quick facts

• Similar to poetry API
• Python compliant
  • Uses .python-version like pyenv
  • Uses pyproject.toml like pip
  • Uses .venv as default
• pyproject.toml governed
• uv venv equivalent to python -m venv .venv
• uv pip ... equivalent to pip ...
• Easy and quick installation
  • curl -LsSf https://astral.sh/uv/install.sh | sh
  • Upgrade with uv self update

Hey there! Here’s a collection of GitHub Actions I’ve found handy for automation. I’ll keep adding to this list as I discover more useful ones. Feel free to grab what you need for your CI/CD workflows!

List of Github action

• https://github.com/astral-sh/setup-uv
• https://github.com/googleapis/release-please
• https://github.com/ncipollo/release-action
• https://github.com/PaulHatch/semantic-version
• https://github.com/mathieudutour/github-tag-action
• https://github.com/slackapi/slack-github-action
• https://github.com/mshick/add-pr-comment
• https://github.com/xt0rted/slash-command-action

Automatic Release

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

name: Publish release
on:
  push:
    branches:
    - "main"
jobs:
    prepare-github-release:
        name: GitHub Release
        runs-on: ubuntu-latest
        outputs:
            version_tag: ${{ steps.calculate_tag_version.outputs.version_tag }}
        steps:

        - name: Checkout repository
          uses: actions/checkout@v4
          with:
            fetch-depth: 0

        - name: Manage semantic versioning
          uses: paulhatch/semantic-version@v5.4.0
          id: calculate_tag_version
          with:
            tag_prefix: ""
            major_pattern: "[MAJOR]"
            minor_pattern: "[MINOR]"
            version_format: "${major}.${minor}.${patch}"
            bump_each_commit: false
            search_commit_body: true
            debug: true

        - name: Bump version and push tag
          id: tag_version
          uses: mathieudutour/github-tag-action@v6.1
          with:
            github_token: ${{ secrets.GH_TOKEN }}
            custom_tag: ${{ steps.calculate_tag_version.outputs.version_tag }}
            tag_prefix: ""

        - name: Create a GitHub release
          uses: ncipollo/release-action@v1.14.0
          with:
            tag: ${{ steps.calculate_tag_version.outputs.version_tag }}
            name: Release ${{ steps.calculate_tag_version.outputs.version_tag }}
            body: ${{ steps.tag_version.outputs.changelog }}

Let’s explore a few different ways to run commands in our terminal from the comfort of neovim. Trust me, it’s cooler than it sounds! 😎

Here’s a list of commands that I use all the time (and you should too!).

# run a command
:!sh <cmd>

# execute the line and replace with the output
:.!sh

# execute without replacing
:.w !sh

# execute without replacing selection and it will persist until next selection!
:'<,'>w !sh

# execute a the line 8
:8w !sh

# execute and replace a the line 8
:8 !sh

# execute the selection in python
:'<,'>w !python -c "$(cat)"

# execute and replace the selection in python
:'<,'>!python -c "$(cat)"

Hands-on

Hey! This is my absolute favorite command ever! I use it all the time when I’m writing docs or README files because, let’s face it - who wants to manually copy-paste code outputs? Not me! 😅 Instead of doing things the boring way, I use this neat little trick to get things done quickly. Plus, it’s super handy when you want to format text using other tools too like sql queries!

Let’s dive into the world of Docker Compose and environment variables, where hilarity ensues and variables come alive (or do they?).

We’ve all been there. Playing hide and seek with environment variables in Docker Compose. Let’s see how our dear friend MYVAR enjoys this grand game of Peekaboo!