DEV Community

Dev du Sud
Dev du Sud

Posted on

317 tâches et 36 projets dans SQLite — le statut « abandonné » m'a plus servi que les autres

Trois cent douze tâches, trente-six projets, un fichier. Pas de serveur, pas d'abonnement, pas
d'application mobile.

Le chiffre qui m'intéresse n'est pas 317. C'est 33 : le nombre de tâches que j'ai
abandonnées — ni faites, ni supprimées, marquées comme telles. C'est le statut qui a le
plus changé ma façon de travailler, et celui qu'aucun outil de gestion de tâches ne met en
avant.

La répartition, brute

SELECT statut, COUNT(*) AS n
  FROM missions
 GROUP BY statut
 ORDER BY n DESC;
Enter fullscreen mode Exit fullscreen mode
done        231
todo         38
abandonne    33
encours      10
Enter fullscreen mode Exit fullscreen mode

Trois cent douze lignes dans ces quatre statuts. La table en contient 317 : les cinq autres sont
des tâches bloquées — quatre qui attendent une décision de ma part, une qui attend un client.
À l'échelle d'un projet, c'est un écart qu'on ne voit pas ; à l'échelle de trois cents lignes,
c'est le genre de trou qu'un tableau de bord propre vous cache.

Ce qui manque encore, c'est la contrainte. Le schéma réel ne l'a pas :

CREATE TABLE missions (
  id       TEXT PRIMARY KEY,
  projet   TEXT NOT NULL,
  titre    TEXT NOT NULL,
  statut   TEXT NOT NULL DEFAULT 'todo'
             CHECK (statut IN ('todo','encours','done','abandonne','bloque_ludo','bloque_externe')),
  type     TEXT NOT NULL DEFAULT 'agent' CHECK (type IN ('agent','humain')),
  preuve   TEXT,
  cree_le  TEXT NOT NULL DEFAULT (datetime('now')),
  maj_le   TEXT NOT NULL DEFAULT (datetime('now'))
);
Enter fullscreen mode Exit fullscreen mode

Une contrainte CHECK ne répare pas les lignes existantes, mais elle empêche la suivante. Sur
SQLite, c'est trois lignes de SQL qui remplacent une convention documentée que personne ne lit.

Dix tâches en cours, et pas une de plus

Dix, sur 317. Ce n'est pas une politique, c'est un constat, et il est plutôt sain : au-delà
d'une douzaine de chantiers ouverts en parallèle, je passe mon temps à changer de contexte au
lieu d'avancer.

La requête qui surveille ça est banale, mais je la regarde chaque semaine :

SELECT projet, COUNT(*) AS en_cours
  FROM missions
 WHERE statut = 'encours'
 GROUP BY projet
 ORDER BY en_cours DESC;
Enter fullscreen mode Exit fullscreen mode

Trente-huit tâches à faire, pour trente-six projets : la plupart des projets ont une tâche
ouverte, quelques-uns en ont trois. Cette forme de distribution est une information en soi —
elle dit que je travaille en largeur, pas en profondeur.

Pourquoi « abandonné » est un statut

Pendant des années, j'ai eu deux façons de traiter une tâche que je ne ferais pas : la
supprimer, ou la laisser en todo pour toujours.

Les deux sont mauvaises.

  • Supprimer efface la décision. Six mois plus tard, je retrouve la même idée, je la recrée, et je repasse une heure à me demander si je l'ai déjà tentée. La réponse était dans une ligne que j'avais effacée.
  • Laisser en todo pollue la liste. Une liste de tâches qui contient vingt lignes qu'on ne fera jamais cesse d'être une liste de tâches : elle devient un cimetière qu'on évite d'ouvrir.

abandonne tranche : la ligne reste, avec sa raison dans le champ note, et elle sort de
toutes les vues de travail. Trente-trois fois, j'ai écrit pourquoi. Trente-trois fois, ça m'a
évité de recommencer.

UPDATE missions
   SET statut = 'abandonne',
       note = note || ' | abandonné: ' || :raison,
       maj_le = datetime('now')
 WHERE id = :id;
Enter fullscreen mode Exit fullscreen mode

Une tâche abandonnée peut revenir : elle repasse en todo, avec son historique. C'est une
décision réversible, ce qui est précisément la raison pour laquelle je la prends plus
facilement.

La colonne qui décide : preuve

Une ligne ne passe pas en done sans un artefact vérifiable. Trois formes acceptées, pas
quatre :

  1. un chemin de fichier qui existe, produit après la création de la tâche ;
  2. une URL qui répond 200 au moment de la clôture ;
  3. un hash de commit.

Le contrôle est mécanique, et il tient en une requête.

-- tâches marquées faites dont la preuve ne pointe plus sur rien
SELECT id, projet, titre, preuve
  FROM missions
 WHERE statut = 'done'
   AND (preuve IS NULL OR preuve = '');
Enter fullscreen mode Exit fullscreen mode

Sur 231 tâches terminées, cette requête doit renvoyer zéro ligne. Elle en renvoie zéro, mais
seulement parce que j'ai passé une soirée à remplir les preuves manquantes quand je l'ai
écrite pour la première fois. Avant ça, il y en avait une trentaine — dont un « site livré »
dont personne ne retrouvait l'URL.

Le contrôle côté fichier, pour les preuves de type chemin :

sqlite3 missions.db "SELECT preuve FROM missions WHERE statut='done' AND preuve LIKE '/%';" \
| while read -r p; do
    [ -f "$p" ] || echo "preuve absente: $p"
  done
Enter fullscreen mode Exit fullscreen mode

Et la partie que je n'automatise pas : vérifier que le fichier a été produit après la
création de la tâche. Un rapport de septembre ne prouve pas un travail de novembre. C'est un
stat comparé à cree_le, et ça se fait à la main quand un doute existe.

Ce que SQLite encaisse, et ce qu'il n'encaisse pas

À 317 lignes et 36 projets, la question de la base ne se pose même pas : le fichier fait moins
d'un mégaoctet, les requêtes sont instantanées, et la sauvegarde est un .backup dans un
cron.

Les limites réelles sont ailleurs, et elles n'ont rien à voir avec le volume :

  • un seul écrivain. Si deux scripts écrivent en même temps, le second attend. Avec PRAGMA busy_timeout = 5000, il attend cinq secondes au lieu de planter. Sur un poste de travail, c'est suffisant ; sur un serveur partagé, ce ne l'est pas.
  • pas de vue partagée. Dès que quelqu'un d'autre doit voir l'état, il faut exporter. Donner accès au fichier, c'est donner accès à tout, y compris aux notes internes.
  • les suppressions de colonnes sont pénibles. Ajouter une colonne est trivial, en retirer une demande de recréer la table. Je garde donc les migrations numérotées dans un dossier, avec PRAGMA user_version comme compteur.

Ce que 317 lignes m'ont appris

Trois choses, et aucune n'est technique.

Un total ne dit rien. 317 tâches, c'est un chiffre de vanité ; 10 en cours, c'est une charge de
travail. La répartition raconte l'état réel du système, pas le total.

Un statut « abandonné » est un outil de clarté, pas un échec. Trente-trois décisions explicites
valent mieux que trente-trois lignes fantômes.

Et une tâche sans preuve est une opinion. La colonne preuve est la seule partie du schéma qui
m'a obligé à changer ma façon de travailler : quand on sait qu'on devra citer un fichier, on
produit le fichier. Pas parce qu'on est discipliné — parce que la case ne se coche pas sinon.

Top comments (0)