---
# System prepended metadata

title: Rendi il tuo workflow di sviluppo più efficiente con questi tool poco noti
tags: [develer, ' blog']

---

---
tags: develer, blog
---

# Rendi il tuo workflow di sviluppo più efficiente con questi tool poco noti

Gli strumenti di sviluppo sono una parte fondamentale del lavoro di ogni programmatore. In questo articolo, vedremo alcune alternative poco conosciute ma altrettanto valide ai tool di sviluppo più diffusi, che potrebbero rendere il nostro workflow di sviluppo ancora più efficiente.

Ci sono tool di sviluppo molto famosi e utilizzati, come ad esempio `git` per la gestione del codice sorgente, `npm` per la gestione delle dipendenze in JavaScript e `pip` per la gestione delle dipendenze in Python. Ma ci sono anche tante altre operazioni per cui ogni sviluppatore ha nelle dita un qualche comando.

Ho fatto un rapido sondaggio in un canale interno per presentare i miei tool "poco famosi" e conoscere quelli degli altri, ed ecco il risultato. Vediamo di raggrupparli per tipologia:

## Modifica del testo

- [`fastmod`](https://github.com/facebookincubator/fastmod) è un tool "cerca e sostituisci", con supporto per regex. La particolarità del tool è che la preview della sostituzione viene visualizzata in forma di diff in modo interattivo.
- [`cog`](https://nedbatchelder.com/code/cog) è una sorta macro Python embeddabile un po' ovunque, si esegue ed espande il codice, quindi si committa sia il codice di generazione che il codice espanso ([esempio](https://gitlab.com/naufraghi/gitlab-butler/-/blob/master/README.md?plain=1#L91)) <details><summary>`README.md`</summary>
    (before)
    ```
    # Readme

    Initially the space between the markers will be empty.

    <!-- [[[cog
    import subprocess
    print("```raw")
    print(subprocess.check_output(["cat", "--help"], text=True))
    print("```")
    ]]] -->
    <!-- [[[end]]] -->

    The file will be modified inplace running `cog -r README.md`.
    ```
    (after)
    ```
    # Readme

    Initially the space between the markers will be empty.

    <!-- [[[cog
    import cog
    import subprocess
    cog.outl("```raw")
    cog.outl(subprocess.check_output(["cat", "--help"], text=True))
    cog.outl("```")
    ]]] -->
    ```raw
    Usage: cat [OPTION]... [FILE]...
    Concatenate FILE(s) to standard output.

    With no FILE, or when FILE is -, read standard input.

      -A, --show-all           equivalent to -vET
      -b, --number-nonblank    number nonempty output lines, overrides -n
      -e                       equivalent to -vE
      -E, --show-ends          display $ at end of each line
      -n, --number             number all output lines
      -s, --squeeze-blank      suppress repeated empty output lines
      -t                       equivalent to -vT
      -T, --show-tabs          display TAB characters as ^I
      -u                       (ignored)
      -v, --show-nonprinting   use ^ and M- notation, except for LFD and TAB
          --help        display this help and exit
          --version     output version information and exit

    Examples:
      cat f - g  Output f's contents, then standard input, then g's contents.
      cat        Copy standard input to standard output.

    GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
    Full documentation <https://www.gnu.org/software/coreutils/cat>
    or available locally via: info '(coreutils) cat invocation'
    
    \```
    <!-- [[[end]]] -->

    The file will be modified inplace running `cog -r README.md`.

    ```
    </details>
    
    L'ho usato per avere un output aggiornato nei file README, oppure per includere snippet di codice nelle slide (remarkjs/latex) o anche per generare codice ripetitivo in linguaggi con introspezione/macro poco potenti (penso a te C/C++).
    Il vantaggio nell'uso di `cog` è che il codice generato è committato, quindi non ci sono nuove dipendenze di build. `cog` è necessario solo quando si vuole modificare il codice generato.

## Ricerca

- [`fd`](https://github.com/sharkdp/fd#readme) è una versione "moderna" di `find`, di default fa la cosa giusta, senza opzione `-name`.
    <details><summary>screencast</summary><img src="https://github.com/sharkdp/fd/raw/master/doc/screencast.svg" title="fd screencast" /></details>
- [`exa`](https://the.exa.website/) A modern replacement for ls. `exa` è un file lister migliorato con più funzionalità e impostazioni predefinite migliori. Utilizza i colori per distinguere i tipi di file e i metadati. Conosce i collegamenti simbolici, gli attributi estesi e Git. L'ho pravato varie volte ma ancora non ha sostituito `ls` nella mia memoria muscolare.

## Monitoraggio

- [`btop`](https://github.com/aristocratos/btop) una alternativa a `top`, nello stile di `htop`, ma ancora più bello. È bello persino <details><summary>l'output del makefile!</summary>![](https://i.imgur.com/7ZvHo2u.png)</details>
- [`duf`](https://github.com/muesli/duf) Disk Usage/Free Utility - a better 'df' alternative<details><summary>demo</summary>![image](https://hackmd.io/_uploads/H1RLMnf_a.png)
</details>

## Visualizzazione

- [`bat`](https://github.com/sharkdp/bat) è una alternativa colorata a `cat` e `less`, anche se alcuni preferiscono 2 righe di bash per ottenere un risultato simile:
  ```bash
  #!/bin/sh
  highlight -l --style=dusk -Oxterm256 "$@" | less -rFX
  ```
- [`tldr`](https://tldr.sh/) Simplified and community-driven man pages. Avete presente la manpage tipica del programma che elenca _prima_ 72782 opzioni astruse, e poi _forse_ un minimo esempio di uso? Ecco, `tldr` invece elenca _prima_ gli usi più comuni, e nel 98% dei casi, quello che ci serve è entro il 3° esempio.

    
## Test

- [`cram`](https://github.com/brodie/cram "Nota: il repo è archiviato") è uno script Python pensato per scrivere test di regressione di tool a linea di comando. I file di test contengono sia il comando da eseguire che l'output atteso (con eventuali wildcard): <details><summary>`test.t`</summary>
  ```t
  Simple commands:

  $ echo foo
  foo
  $ printf 'bar\nbaz\n' | cat
  bar
  baz
  ```
</details>
    
## Git

- `git freeze` / `git thaw` dal repo [depot_tools](https://commondatastorage.googleapis.com/chrome-infra-docs/flat/depot_tools/docs/html/depot_tools.html) di Chrome. Il repo contiene tanti altri script, ma questi due sono comodi per cambiare velocemente branch a metà di un lavoro.
    - `git freeze` crea un commit con tutti i file tracciati e non tracciati nel branch locale (una sorta di `stash` per branch)
    - `git thaw` fa il revert di quel commit.
- [`git-absorb`](https://github.com/tummychow/git-absorb) prende quello che c'è nell'index e cerca tra i commit recenti quello che ha toccato linee vicine a quelle di un hunk. Se ne trova, prepara un commit di fixup consumando quell'hunk dall'index. Comodo per fixup di typo o cose del genere.
    
## More
    
- [moreutils](https://joeyh.name/code/moreutils/) è una collezione di tool per compiti un po' particolari, vanno a sostituire una pipeline non banale di comandi bash con una interfaccia più comoda. Ad esempio: `ts` per beanchmark alla buona e `vipe` per aprire in un editor l'output di una pipe.
    <details><summary>Leggete le descrizioni per vedere se almeno uno vi potrebbe essere utile, sono pacchettizati in Debian.</summary>

   `chronic`: runs a command quietly unless it fails
   `combine`: combine the lines in two files using boolean operations
   `errno`: look up errno names and descriptions
   `ifdata`: get network interface info without parsing ifconfig output
   `ifne`: run a program if the standard input is not empty
   `isutf8`: check if a file or standard input is utf-8
   `lckdo`: execute a program with a lock held
   `mispipe`: pipe two commands, returning the exit status of the first
   `parallel`: run multiple jobs at once
   `pee`: tee standard input to pipes
   `sponge`: soak up standard input and write to a file
   `ts`: timestamp standard input
   `vidir`: edit a directory in your text editor
   `vipe`: insert a text editor into a pipe
   `zrun`: automatically uncompress arguments to command

  </details>

- `stow` (GNU) per creare symlink in modo intelligente (utilissimo per installare in un commando tutti i tuoi dotfiles, da un repo git verso la tua home)
    
## Stats
    
- [`pct`](https://github.com/josharian/pct) è un `sort | uniq -c | sort -n -r` che ti stampa anche le percentuali
- [`dist`](https://github.com/aclements/go-moremath/blob/master/cmd/dist/dist.go) legge numeri line-by-line e ti stampa la loro distribuzione (sia visualmente che i percentili significativi, min, max e media).
  <details><summary>Come si installa?</summary>
      
  `go install github.com/aclements/go-moremath/cmd/dist@latest` che installa in `$GOPATH/bin` oppure `$HOME/go/bin` se `GOPATH` non è definito.
      
  </details>
- [`hyperfine`](https://github.com/sharkdp/hyperfine) A command-line benchmarking tool. È un tool che esegue un comando varie volte e poi espone delle statistiche del tempo di esecuzione.<details><summary>demo</summary>![image](https://hackmd.io/_uploads/ByRjv2f_6.png)
</details>

    
## Da provare
    
- [`jc`](https://kellyjonbrazil.github.io/jc/) _CLI tool and python library that converts the output of popular command-line tools, file-types, and common strings to JSON, YAML, or Dictionaries. This allows piping of output to tools like jq and simplifying automation scripts._
è un tool molto interessante, implementa tantissimi parser per output di programmi e permette di convertire un output umano in formato json, per poi processarlo con tool tipo `jq`.
    
## Tool ormai famosi
    
- [`ag`](https://github.com/ggreer/the_silver_searcher#readme) _the silver searcher_ è un tool di ricerca che ha sostituito nella mia memoria muscolare il vecchio `grep -lIris`. Molto veloce, con default sani, è un diretto competitor di [`ripgrep`](https://github.com/BurntSushi/ripgrep). Alcuni dicono che ormai dovrebbe essere reato non avere `ag` di default su un sistema Linux :smile:.
- [`fzf`](https://github.com/junegunn/fzf) command line fuzzy finder. Utilissimo per creare piccoli alias/scripts con fuzzy-finding gratuito. Ad esempio il mio collega Aurélien ha scritto `fco` (fuzzy git checkout) per scrivere poche lettere del branch e autocompletare il resto, `fkill` per killare processi by name via fuzzy finding, `fv` per aprire file in vim, etc. Se volete il codice, chiedete a lui al prossimo [GoLab](https://golab.io)!

# Conclusione
    
Spero che qualche tool presentato in questo articolo vi sia utile ad automatizzare qualche compito noioso. Così potrete dedicare più tempo alle cose interessanti!