Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Efectes secundaris

Aquest document explica què és un efecte secundari (side effect), d’on ve, per què cal gestionar-lo i com es fa: primer font per font, després segons cada paradigma de programació, i finalment amb la programació orientada a efectes, aplicada pas a pas a un exemple en Java. Amplia les definicions breus de Principis.

Funcions pures i impures

Compara aquests tres mètodes:

// Pura: el resultat només depèn dels arguments
static int add(int a, int b) { return a + b; }

// Impura: llegeix i modifica un estat de fora
static int counter = 0;
static int next() { return ++counter; }

// Impura: depèn del rellotge
static boolean isMorning() { return LocalTime.now().getHour() < 12; }

add només calcula. next i isMorning fan alguna cosa més que retornar un valor: modifiquen una variable de fora o consulten el món. Aquesta “alguna cosa més” és un efecte secundari (side effect), també dit efecte col·lateral: qualsevol interacció d’una funció amb l’exterior que no sigui rebre arguments i retornar un resultat. Escriure en un fitxer, fer una petició HTTP, imprimir per pantalla, llegir el rellotge o llançar una excepció en són exemples.

Una funció sense efectes secundaris, que sempre retorna el mateix resultat per als mateixos arguments, és una funció pura (pure function). La seva crida es pot substituir pel valor que retorna sense canviar el programa, i aquesta propietat és la transparència referencial (referential transparency):

System.out.println(add(2, 3) + add(2, 3));   // 10
System.out.println(2 * add(2, 3));           // 10: podem substituir la crida pel seu valor
System.out.println(next() + next());         // 3 (1 + 2)
System.out.println(2 * next());              // 6: el mateix canvi dona un altre resultat

D’on venen

Una funció té efectes secundaris quan fa alguna d’aquestes coses:

FontExemples en JavaPer què és un efecte
Modificar estat de foraassignar un camp static, canviar un atribut de l’objecte, afegir elements a una llista rebuda per paràmetreAltres parts del programa veuen el canvi
Llegir estat que canviaLocalTime.now(), Math.random(), System.getenv(), un camp que algú altre modificaEl resultat ja no depèn només dels arguments
Entrada/sortidaSystem.out.println, Files.readString, HttpClient.send, una consulta JDBCInteractua amb el món exterior, que pot canviar o fallar
Fallarthrow new ..., una excepció que es propagaLa funció no retorna cap valor: l’execució salta a un altre lloc
EsperarThread.sleep, una crida bloquejantEl temps que triga forma part del comportament
Llançar feina concurrentcrear un thread, executor.submit(...)Hi ha feina que continua quan la funció ja ha retornat

Llegir també compta: isMorning() no modifica res, però dona resultats diferents segons quan es crida, i per tant no és pura.

Els efectes, a més, es contagien. Una funció que crida una funció impura també és impura, encara que el seu codi sembli innocent. Un mètode calculaFactura() que en algun punt de la cadena de crides llegeix el rellotge o consulta la base de dades ja no és un càlcul, i res a la seva signatura ho diu. Per això, en un programa on no es controlen, els efectes acaben escampats per tot arreu.

Per què cal gestionar-los

Els programes útils necessiten efectes secundaris: un programa que no llegeix ni escriu res no serveix de res. El problema no és que existeixin, sinó que no es veuen. Per això gestionar-los no vol dir eliminar-los, sinó saber on són i decidir quan i com s’executen. Com que es contagien, si no es gestionen acaben a tot arreu, i aquests problemes afecten tot el programa:

ProblemaExempleQuè canvia quan es gestionen
Raonar costa mésPer entendre next() no n’hi ha prou amb la signatura: cal saber què fa amb counter i qui més el tocaLa major part del codi és pur: per entendre’l n’hi ha prou de llegir-lo
Provar costa mésisMorning() dona un resultat diferent segons l’hora a què s’executa la provaEls efectes (base de dades, rellotge, xarxa) entren com a dependències, i a les proves se substitueixen per versions falses que responen a l’instant
L’ordre importaDues crides amb efectes no es poden reordenar ni repetir sense canviar el resultatLes parts pures es poden reordenar, reutilitzar, desar en memòria cau o executar en paral·lel sense por
La concurrència s’embolicaSi dos threads criden next() alhora, poden llegir el mateix valor de counter i perdre un incrementLes dades immutables es poden compartir entre threads sense sincronització
Els errors arriben per sorpresaUna crida de xarxa pot fallar, però User fetchUser(String id) no ho diu, i l’error apareix a produccióSi l’error forma part del tipus de retorn, el compilador obliga a tractar-lo

L’error de concurrència és una condició de carrera (race condition), explicada a Interferència de fils. Com el disseny facilita o dificulta les proves es tracta a Disseny per a la testabilitat.

Hi ha un altre benefici, menys evident: saber quines crides tenen efectes permet decidir-ne l’execució. Reintentar una consulta que ha fallat és segur; reintentar una crida que envia un correu pot enviar-lo dues vegades. Una funció pura es pot cridar tantes vegades com calgui; una amb efectes, no. Si els efectes no es veuen, no es pot prendre aquesta decisió.

Com gestionar cada font

Cada font d’efectes de la taula D’on venen té una manera habitual de gestionar-la:

FontCom es gestionaEines a Java
Modificar estat de foraRetornar valors nous en lloc de modificar els compartits. Si cal mutar, fer-ho només dins de l’objecte que és amo d’aquell estatrecord, List.of, camps final, encapsulació
Llegir estat que canviaRebre’l com a paràmetre o dependència, en lloc de llegir-lo dins de la funcióClock, Random amb llavor fixa, configuració llegida un cop a l’inici i passada cap avall
Entrada/sortidaEmpènyer-la a la vora: el nucli treballa amb dades, i els adaptadors de les fronteres llegeixen i escriuenports i adaptadors, nucli funcional amb closca imperativa
FallarPosar els errors esperats a la signatura, deixar els bugs com a excepcions no comprovades i traduir les excepcions de la infraestructura a les fronteresResult amb tipus segellats, excepcions comprovades
EsperarPosar sempre un temps límit, i amagar l’espera darrere d’una interfície perquè les proves no esperin de debòFuture.get amb temps límit, una interfície Sleeper, virtual threads
Llançar feina concurrentEvitar que la feina concurrent sobrevisqui a la funció que l’ha començat, i compartir només dades immutablesexecutors amb try-with-resources, StructuredTaskScope (en preview a Java 25)

La idea comuna és la mateixa a totes les files: treure l’efecte de dins de la funció, o bé convertint-lo en una dada (un valor retornat, un paràmetre, un resultat d’error), o bé portant-lo a una frontera coneguda on es pot substituir.

Dues de les files necessiten una explicació més:

  • Entrada/sortida. El patró nucli funcional, closca imperativa (functional core, imperative shell) separa el programa en dues capes. La closca llegeix les dades (base de dades, fitxers, xarxa), crida el nucli, que és pur i decideix què cal fer, i després escriu el resultat. Tota la lògica queda al nucli, que es prova sense infraestructura. És la mateixa idea que les arquitectures hexagonal i clean.
  • Llançar feina concurrent. Un ExecutorService dins d’un try-with-resources espera que acabin totes les tasques abans de sortir del bloc, de manera que cap tasca queda en marxa sense que ningú la vigili. StructuredTaskScope va més enllà: si una tasca falla, cancel·la les altres.

Per aprofundir: l’estat compartit entre threads a Estratègies, les dependències i les proves a Disseny per a la testabilitat, i les maneres de tractar errors a Gestió d’errors.

Com els han tractat els paradigmes

Cada paradigma ha respost a la mateixa pregunta: com controlar els efectes secundaris sense renunciar-hi? Algunes respostes es basen en convencions i disseny; d’altres, en el compilador.

Programació imperativa i procedimental. Els efectes són lliures i invisibles. L’únic control són les convencions: noms clars, documentació i disciplines com la separació ordre-consulta (command-query separation, CQS) de Bertrand Meyer, que demana que un mètode o bé retorni un valor (consulta) o bé canviï l’estat (ordre), però no totes dues coses alhora.

Programació orientada a objectes. L’encapsulació amaga l’estat darrere d’una interfície: no elimina els efectes, però limita qui pot provocar-los. Les arquitectures que en deriven (injecció de dependències, l’arquitectura hexagonal amb els seus ports i adaptadors) aïllen els efectes en objectes concrets que es poden substituir.

Programació funcional. Proposa escriure la major part del programa amb funcions pures i dades immutables (que no es modifiquen un cop creades), i empènyer els efectes cap a la vora. Hi ha dues maneres d’aplicar-ho:

  • Per disciplina. Llenguatges com Lisp, OCaml, Scala o Clojure permeten efectes en qualsevol lloc, però el seu estil i les seves biblioteques empenyen cap a la puresa i la immutabilitat. Java ha adoptat part d’aquesta idea: els record i List.of són immutables, i els streams demanen lambdes sense efectes secundaris (vegeu Stream API).
  • Imposada pel llenguatge. A Haskell, totes les funcions són pures. Una funció amb efectes no els fa, sinó que retorna una descripció de què caldria fer, de tipus IO: getLine té tipus IO String, “una acció que, quan s’executi, produirà un String”. Només el runtime executa aquestes accions, a la vora del programa. Les accions es combinen amb mònades (monads), una interfície semblant al flatMap de Java.

Programació declarativa i reactiva. Les interfícies d’usuari declaratives (React, per exemple) descriuen la UI com una funció de l’estat, i treuen els efectes (carregar dades d’un servidor, desar-les, temporitzadors) a uns gestors d’efectes (side-effect handlers) separats, que reaccionen als canvis d’estat. La UI queda pura i els efectes, en un lloc conegut. Es tracta a Paradigma declaratiu.

Sistemes de tipus i d’efectes. Alguns llenguatges posen certs efectes a la signatura perquè el compilador els controli:

  • Les excepcions comprovades de Java (1995) són un dels pocs casos mainstream: throws X declara l’efecte “pot fallar”, i el compilador obliga a tractar-lo o a declarar-lo.
  • Rust fa explícita la mutació (&mut) i els errors (Result), però no l’E/S.
  • Koka inclou tots els efectes al tipus de cada funció, i els efectes algebraics (algebraic effects) d’OCaml 5 i Unison permeten definir efectes nous i decidir com s’executen amb gestors (handlers), de manera semblant a un try/catch generalitzat.

Programació orientada a efectes. És la resposta més recent, i es tracta a la secció següent.

ParadigmaEstratègiaQui ho controla
ImperatiuConvencions, CQSEl programador
Orientat a objectesEncapsulació, injecció de dependènciesEl disseny
Funcional per disciplinaFuncions pures i immutabilitat per defecteL’estil i les biblioteques
Funcional pur (Haskell)Efectes com a valors IO, executats a la voraEl compilador
Declaratiu i reactiuUI pura, efectes en gestors separatsEl framework
Sistemes d’efectes (Koka, efectes algebraics)Efectes a la signatura, gestors que els interpretenEl compilador
Orientat a efectes (Effect-TS, ZIO)Efectes com a valors amb errors i requisits tipatsEl compilador, via una biblioteca

Programació orientada a efectes

La programació orientada a efectes (effect-oriented programming) combina idees dels paradigmes anteriors i fa sistemàtica la idea comuna de Com gestionar cada font: treure l’efecte de dins de la funció. Es pot resumir en tres regles:

  1. L’error com a valor. El que pot fallar va al tipus de retorn (un Result segellat amb un switch exhaustiu), no en una excepció amagada.
  2. Declarar què necessita la feina. Les dependències (base de dades, rellotge) entren com a paràmetres o pel constructor, no es busquen a dins (vegeu Com gestionar cada font).
  3. Descriure la feina en lloc de fer-la. Un pla descriu què cal fer però no ho fa, i s’executa més tard, a la vora del programa.

Biblioteques com ZIO (Scala) i Effect-TS (TypeScript) implementen el model complet, amb tipus específics per a cada regla. Amb el JDK es pot aplicar igualment, i la millor manera de veure-ho és partir de codi Java ordinari i aplicar les regles una a una. Cada versió substitueix l’anterior.

Java ordinari

Un mètode que saluda un usuari després de buscar-lo a la xarxa. La xarxa se simula amb un comptador que fa fallar les dues primeres crides:

record User(String id, String name) {}

static int calls = 0;   // simula una xarxa que falla les dues primeres vegades

static User fetchUser(String id) {
  System.out.println("querying " + id);
  if (++calls < 3) throw new RuntimeException("network error");
  return new User(id, "Ada");
}

static String greeting(String id) {
  return "Hello, " + fetchUser(id).name();
}

System.out.println(greeting("42"));
querying 42
Exception in thread "main" java.lang.RuntimeException: network error

greeting sembla un càlcul, però l’efecte de fetchUser s’hi ha contagiat. Té tres problemes: la signatura no diu que pot fallar, necessita la xarxa real i no hi ha manera de provar-lo sense, i s’executa en el moment de cridar-lo, de manera que reintentar-lo obliga a canviar el codi que el crida.

Regla 1: l’error com a valor

fetchUser i greeting retornen un Result, i el cridador ha de tractar els dos casos:

sealed interface Result<T> permits Ok, Err {}
record Ok<T>(T value)     implements Result<T> {}
record Err<T>(String why) implements Result<T> {}

static Result<User> fetchUser(String id) {
  System.out.println("querying " + id);
  return ++calls < 3 ? new Err<>("network error") : new Ok<>(new User(id, "Ada"));
}

static Result<String> greeting(String id) {
  return switch (fetchUser(id)) {
    case Ok<User>(var u)    -> new Ok<>("Hello, " + u.name());
    case Err<User>(var why) -> new Err<>(why);
  };
}

switch (greeting("42")) {
  case Ok<String>(var text) -> System.out.println(text);
  case Err<String>(var why) -> System.out.println("error: " + why);
}
querying 42
error: network error

El programa ja no peta: l’error arriba com un valor, i si el switch en deixa un cas, no compila.

Regla 2: declarar què necessita

La xarxa deixa de ser a dins de greeting i hi entra com a paràmetre, amb una interfície:

interface UserApi { Result<User> fetch(String id); }

static Result<String> greeting(UserApi api, String id) {
  return switch (api.fetch(id)) {
    case Ok<User>(var u)    -> new Ok<>("Hello, " + u.name());
    case Err<User>(var why) -> new Err<>(why);
  };
}

// a les proves, una API falsa que respon a l'instant, sense xarxa
UserApi fake = id -> new Ok<>(new User(id, "Test"));
System.out.println(greeting(fake, "42"));
Ok[value=Hello, Test]

Ara la signatura diu tot el que greeting necessita, i les proves no depenen de la xarxa.

Regla 3: descriure la feina en lloc de fer-la

greeting retorna un pla, un Supplier que no fa res fins que algú crida get(). Com que el pla és un valor, s’hi pot afegir comportament des de fora, com un retry. La xarxa que falla és ara una implementació més de UserApi:

static class FlakyApi implements UserApi {
  int calls = 0;   // falla les dues primeres vegades
  public Result<User> fetch(String id) {
    System.out.println("querying " + id);
    return ++calls < 3 ? new Err<>("network error") : new Ok<>(new User(id, "Ada"));
  }
}

static Supplier<Result<String>> greeting(UserApi api, String id) {
  return () -> switch (api.fetch(id)) {
    case Ok<User>(var u)    -> new Ok<>("Hello, " + u.name());
    case Err<User>(var why) -> new Err<>(why);
  };
}

static <T> Supplier<Result<T>> retry(Supplier<Result<T>> plan, int times) {
  return () -> {
    Result<T> r = plan.get();
    for (int i = 1; i < times && r instanceof Err<T>; i++) r = plan.get();
    return r;
  };
}

var plan = retry(greeting(new FlakyApi(), "42"), 3);   // encara no ha passat res
System.out.println("plan ready");
switch (plan.get()) {                                  // la vora del programa l'executa
  case Ok<String>(var text) -> System.out.println(text);
  case Err<String>(var why) -> System.out.println("error: " + why);
}
plan ready
querying 42
querying 42
querying 42
Hello, Ada

Fins al plan.get() no hi ha cap efecte, i és allà, a la vora del programa, on es decideix quan, quantes vegades i amb quina implementació de UserApi s’executa. Amb una crida directa, retry(greeting(...), 3) rebria un resultat, no la feina, i no podria repetir-la.

Què ha canviat

Problema del codi ordinariRegla que el resolCom es veu a la versió final
La signatura no diu que pot fallarL’error com a valorResult<String>, i un switch incomplet no compila
Necessita la xarxa realDeclarar què necessitaUserApi és un paràmetre; les proves hi passen una API falsa
S’executa en cridar-loDescriure la feinaUn Supplier que la vora executa, amb retry afegit des de fora

El que el JDK no fa és combinar automàticament els tipus d’error ni les dependències quan una funció en crida unes altres que en tenen de diferents, i aquí és on ZIO i Effect-TS aporten més. Com a contrapartida, aquest estil demana més codi i patrons poc habituals en un equip Java, de manera que convé aplicar-lo on el guany és més clar: a la lògica de negoci i a les crides externes que poden fallar.

Després

Disseny aplica aquestes idees al codi de cada dia: empènyer els efectes cap a les fronteres, preferir funcions pures i injectar les dependències perquè el codi es pugui provar.

Last change: , commit: 4a1fce9