Efectes secundaris
- Funcions pures i impures
- D’on venen
- Per què cal gestionar-los
- Com gestionar cada font
- Com els han tractat els paradigmes
- Programació orientada a efectes
- Després
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:
| Font | Exemples en Java | Per què és un efecte |
|---|---|---|
| Modificar estat de fora | assignar un camp static, canviar un atribut de l’objecte, afegir elements a una llista rebuda per paràmetre | Altres parts del programa veuen el canvi |
| Llegir estat que canvia | LocalTime.now(), Math.random(), System.getenv(), un camp que algú altre modifica | El resultat ja no depèn només dels arguments |
| Entrada/sortida | System.out.println, Files.readString, HttpClient.send, una consulta JDBC | Interactua amb el món exterior, que pot canviar o fallar |
| Fallar | throw new ..., una excepció que es propaga | La funció no retorna cap valor: l’execució salta a un altre lloc |
| Esperar | Thread.sleep, una crida bloquejant | El temps que triga forma part del comportament |
| Llançar feina concurrent | crear 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:
| Problema | Exemple | Què canvia quan es gestionen |
|---|---|---|
| Raonar costa més | Per entendre next() no n’hi ha prou amb la signatura: cal saber què fa amb counter i qui més el toca | La major part del codi és pur: per entendre’l n’hi ha prou de llegir-lo |
| Provar costa més | isMorning() dona un resultat diferent segons l’hora a què s’executa la prova | Els 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 importa | Dues crides amb efectes no es poden reordenar ni repetir sense canviar el resultat | Les parts pures es poden reordenar, reutilitzar, desar en memòria cau o executar en paral·lel sense por |
| La concurrència s’embolica | Si dos threads criden next() alhora, poden llegir el mateix valor de counter i perdre un increment | Les dades immutables es poden compartir entre threads sense sincronització |
| Els errors arriben per sorpresa | Una 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:
| Font | Com es gestiona | Eines a Java |
|---|---|---|
| Modificar estat de fora | Retornar valors nous en lloc de modificar els compartits. Si cal mutar, fer-ho només dins de l’objecte que és amo d’aquell estat | record, List.of, camps final, encapsulació |
| Llegir estat que canvia | Rebre’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/sortida | Empènyer-la a la vora: el nucli treballa amb dades, i els adaptadors de les fronteres llegeixen i escriuen | ports i adaptadors, nucli funcional amb closca imperativa |
| Fallar | Posar els errors esperats a la signatura, deixar els bugs com a excepcions no comprovades i traduir les excepcions de la infraestructura a les fronteres | Result amb tipus segellats, excepcions comprovades |
| Esperar | Posar 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 concurrent | Evitar que la feina concurrent sobrevisqui a la funció que l’ha començat, i compartir només dades immutables | executors 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
ExecutorServicedins 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.StructuredTaskScopeva 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
recordiList.ofsó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:getLineté tipusIO String, “una acció que, quan s’executi, produirà unString”. Només el runtime executa aquestes accions, a la vora del programa. Les accions es combinen amb mònades (monads), una interfície semblant alflatMapde 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 Xdeclara 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/catchgeneralitzat.
Programació orientada a efectes. És la resposta més recent, i es tracta a la secció següent.
| Paradigma | Estratègia | Qui ho controla |
|---|---|---|
| Imperatiu | Convencions, CQS | El programador |
| Orientat a objectes | Encapsulació, injecció de dependències | El disseny |
| Funcional per disciplina | Funcions pures i immutabilitat per defecte | L’estil i les biblioteques |
| Funcional pur (Haskell) | Efectes com a valors IO, executats a la vora | El compilador |
| Declaratiu i reactiu | UI pura, efectes en gestors separats | El framework |
| Sistemes d’efectes (Koka, efectes algebraics) | Efectes a la signatura, gestors que els interpreten | El compilador |
| Orientat a efectes (Effect-TS, ZIO) | Efectes com a valors amb errors i requisits tipats | El 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:
- L’error com a valor. El que pot fallar va al tipus de retorn (un
Resultsegellat amb unswitchexhaustiu), no en una excepció amagada. - 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).
- 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 ordinari | Regla que el resol | Com es veu a la versió final |
|---|---|---|
| La signatura no diu que pot fallar | L’error com a valor | Result<String>, i un switch incomplet no compila |
| Necessita la xarxa real | Declarar què necessita | UserApi és un paràmetre; les proves hi passen una API falsa |
| S’executa en cridar-lo | Descriure la feina | Un 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.