Strange Patterns

02 September 2019

WebAssembly in Action

Technical reviewed:

WebAssembly in Action
With examples using C++ and Emscripten

Gerard Gallant
November 2019 ISBN 9781617295744 448 pages

https://www.manning.com/books/webassembly-in-action

01 September 2019

Programming with Types

Technical reviewed:

Programming with Types
Vlad Riscutia
MEAP began April 2019 Publication in November 2019

https://www.manning.com/books/programming-with-types

31 August 2019

The Computer Science Activity Book

An exercise with my son.

The Computer Science Activity Book
24 Pen-and-Paper Projects to Explore the Wonderful World of Coding (No Computer Required!)
by Christine Liu and Tera Johnson

https://nostarch.com/csactivities

Get Programming with Haskell

Technical reviewed:

Get Programming with Haskell
Will Kurt
March 2018

https://www.manning.com/books/get-programming-with-haskell

Practical Haskell A Real World Guide to Programming

Technical reviewed:

Practical Haskell
A Real World Guide to Programming
Authors: Serrano, Alejandro
© 2019

https://www.apress.com/gp/book/9781484244791

29 August 2019

Java 8 parallel streams pitfall

1.
All parallel streams use a common fork-join thread pool, and if you submit a long-running task, you effectively block all threads in the pool. Consequently, you block all other tasks that are using parallel streams.

2.
The default processing that occurs in such a Stream uses the ForkJoinPool.commonPool(), a Thread Pool shared by the entire application.

3.
This way we essentially force the parallel stream to have a ForkJoin as a parent thread, instead of a regular thread, so ForkJoinPool.commonPool is not used. Hooray!

20 August 2019

Spring MVC AsyncRestTemplate

Simple example to call Async RestTemplate :

https://github.com/devwebcl/async-springmvc-poc

Most important snippet code:

public AsyncRestTemplate asyncRestTemplateFactory() {
PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();

connManager.setMaxTotal(maxTotalConnections);
connManager.setDefaultMaxPerRoute(maxConnectionsPerRoute);
CloseableHttpClient httpClient = HttpClientBuilder.create().setConnectionManager(connManager).build();
HttpComponentsAsyncClientHttpRequestFactory requestAsyncFactory =
new HttpComponentsAsyncClientHttpRequestFactory();
requestAsyncFactory.setConnectionRequestTimeout(connectRequestTimeout);
requestAsyncFactory.setConnectTimeout(connectTimeout);
requestAsyncFactory.setReadTimeout(readTimeout);
requestAsyncFactory.setHttpClient(httpClient);

AsyncRestTemplate art = new AsyncRestTemplate();
art.setAsyncRequestFactory(requestAsyncFactory);

//deberia ser inyectado desde DI container
return new AsyncRestTemplate(requestAsyncFactory);
}

and

public String callback() throws Exception {

        Map<String, ListenableFuture<ResponseEntity<String>>> futures = new HashMap<>(); //podria ser un Guava Table
        List<String> respuestas = new ArrayList<>();


        AsyncFactory af = new AsyncFactory();
        AsyncRestTemplate artf = af.asyncRestTemplateFactory();

        //url a visitar
        String[] url = {"http://google.com", "http://bing.com", "https://stackoverflow.com/", "https://www.infoq.com/", "https://dzone.com/",
                        "https://jakarta.ee/", "https://www.eclipse.org/", "http://www.noexisto.cl/", "https://spring.io/", "https://github.com/",
                        "https://www.apache.org/"};


        //agrego llamadas asincronas
        for(int i=0; i<url.length; i++) {

            HttpMethod method = HttpMethod.GET;
            Class<String> responseType = String.class;
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.TEXT_PLAIN);
            HttpEntity<String> requestEntity = new HttpEntity<>("params", headers);
            //la llave es la misma url (modificable)

            // usar DeferredResult ?
            ListenableFuture<ResponseEntity<String>> future = artf.exchange(url[i], method, requestEntity, responseType);


            // es "opcional"
            future.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
                  @Override
                  public void onSuccess(ResponseEntity<String> result) {
                    System.out.println("onSuccess " + result.getHeaders() );
                    //TODO: DeferredResult ?
                  }

                  @Override
                  public void onFailure(Throwable ex) {
                    System.out.println("onFailure!!! " + ex );
                  }
                });

             futures.put(url[i], future);
        }


        //TODO: borrar !
        // duermo los hilos solo por prueba:
        int segundos_sleep = 2;
        System.out.println("durmiendo por " + segundos_sleep + " segundos...");
        Thread.sleep(segundos_sleep * 1000);


        int i=0;
        //voy uno a uno... con Guava SuccessfulAsList seria lo mismo al final ya que quiero cada uno de los responses
        for (Map.Entry<String, ListenableFuture<ResponseEntity<String>>> llave : futures.entrySet()) {

            System.out.println((++i)+". -----------------------------------------------------\n");

            System.out.println("key = " + llave.getKey() + ",\n value = " + llave.getValue());

            ListenableFuture<ResponseEntity<String>> future = llave.getValue();
            ResponseEntity<String> entity = null;

            try {

            entity = future.get(); // blocking en cada uno, pero la respuesta ya puede existir
            } catch (InterruptedException ie) {
                ie.printStackTrace();
                continue;
            } catch (ExecutionException ee) {
                ee.printStackTrace();
                continue;
            }


            String headers = entity.getHeaders().toString();

            if(headers.indexOf("domain=")!=-1)
                System.out.println(headers.substring(headers.indexOf("; domain=")));
            else
                System.out.println(headers);

            System.out.println(entity.getStatusCode());
            //System.out.println(entity.getBody());
            respuestas.add(entity.getBody().toString());

            System.out.println("isDone? " + future.isDone() + "\n");
        }



        System.out.println("\nfin.");


        //return respuestas;
        return "done";
    }