Flujo de datos

    String readAsString(InputStream stream) throw IOException{
        val reader = new InputStreamReader(stream);
        return CharStreams.toString(reader);
    }

    List<String> readAsLines(InputStream stream) throw IOException{
        return IOUtils.readLines(stream);
    }

    void main(){
      val input = new FileInputStream("myfile.txt");
      println("content: " + readAsString(input));
      println("lines: " + readAsLines(input));
    }
                

    String readAsString(InputStream stream) throw IOException{
        val reader = new InputStreamReader(cloneOf(stream));
        return Streams.toString(reader);
    }

    List<String> readAsLines(InputStream stream) throw IOException{
        return IOUtils.readLines(cloneOf(stream));
    }

    InputStream cloneOf(InputStream input){
      val cloned ....
      return cloned;
    }
                

No tocar el estado global

No modificar datos de entrada

No interrumpir el flujo de ejecución

No usar NULL

Inmutabilidad

El problema que tenemos es que por años hemos enseñado efectivamente a generaciones de programadores que el estado mutable nos permite trabajar de la mejor forma. Ahora estamos en una carrera para enseñar que no todo eso es cierto

Anders Hejlsberg, SEI-Radio, 2008

Valores < - > Tiempo

Git / Mercurial / Fossil

Acoplamiento temporal

Request req = new Request("http://juanbandafanpage.com");
req.method(Request.POST);
request.body("fanId=chichico");
request.fetch();
                

                
Request req = new Request("http://juanbandafanpage.com");
// req.method(Request.POST);
request.body("fanId=chichico");
request.fetch(); //NPE!!!
                

Acoplamiento temporal

Request req = new Request("http://juanbandafanpage.com");
req = req.body("fanId=chichico");
req = req.post();
req.fetch();
                
                
Request req = new Request("http://juanbandafanpage.com");
req.body("fanId=chichico").post().fetch();
                

• java.lang.String
• java.util.Date
• com.google.guava

Todo valor es inmutable por defecto

Todo valor modificado, genera un nuevo valor

Los estados mutables son privados/locales

Estilo declarativo

Diga lo que hace, haga lo que dice

int countBugs(String filePath){
  Path path = Paths.get(filePath);
  int count = 0;

  try(FileReader reader = new FileReader(
        Files.newInputStream(path))
     ){
      String line = null;
      while( (line = reader.readLine()) != null )
          if(line.contains(“BUG”))
             count++;

  }catch(IOException e){
    printErr(e);
  }
}
            

int countBugs(String filePath){
  return Files.readAllLines(Paths.get(filePath))
      .stream()
      .filter(line -> line.contains(“BUG”))
      .count();
}
                

Mas ejemplos?

List<Deposit> deposits= …;


// give me the big transfers
long allBigTransfers = deposits.stream()
  .filter(d -> d.amount > 10000L)
  .mapToLong(d -> t.amount)
  .sum();


// give me the smallest transfer
Optional<> minTransfer = deposits.stream()
         .min((d1, d2) -> d1 > d2);

                

Enfocarse en el qué, no en el cómo

Abstraer infraestructura

Generar expresiones, y no órdenes

Datos como datos

HttpServletRequest

getAsyncContext,getAttribute, getAttributeNames,
getCharacterEncoding,getLength,getContentLength,
getType,getContentType,getDispatcherType,getLocalName,
getLocalAddr,getLocale,getLocales,getLocalName,
getLocalPort,getParameterNames,getParameterValues,
getProtocol,getReader,getRealPath,getRemoteAddr,
getRemoteHost,getRemotePort,getRequestDispatcher,
getScheme,getServerName,getServerPort,isSecure,
removeAttribute,setAttribute,setCharacterEncoding,
startAsync,getHeader,getHeaderNames,getIntHeader,
getResponseStream,
...
                

[
  "remote-addr": "127.0.0.1",
  "scheme": "http",
  "form-params": [],
  "query-string": "fanId=chichico",
  "request-method": "GET",
  "content-type": "text/csv",
  "server-name": "localhost",
  "params": ["key": "value"],
  "server-port": 8080,
  "headers": [
      "accept-encoding" : "gzip, deflate",
      "connection": "close",
      "content-length": 0,
      ...
    ]
]
                

class CustomerId{
  private int id;
  private String value;
  //.....
  
}

class InValue{
  private int id;
  private String value;
  private int type;
  //...
}

class OutValue{
  //...
}

class InValueContainer{
  //...
}

class OutValueContainer{
  //...
}
                

Efectos

Inconsistencia

Duplicidad

Acoplamiento

La especificidad esta sobre-valorada

Primitives

Lists

Sets

Dictionary

Usar primitivos hasta donde se pueda

Usar estructuras hasta donde se pueda

Evitar los objetos anémicos

Evitar estructuras hereditarias