Beginning Perl Programming

Technical reviewed:

© 2019
Beginning Perl Programming
From Novice to Professional
Authors: Rothwell, William \Bo\

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

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

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

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

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!

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";
    }

  

Hungarian algorithm

When there are rows/columns, where each row is a job and each row is a worker.

We need to find the lowest cost to pair (row, column):

	Job 1	Job 2	Job 3
Worker 1	2	3	3
Worker 2	3	2	3
Worker 3	3	3	2

Solution: 2, 2, 2 = 6

• https://github.com/devwebcl/Hungarian-Algorithm
• https://en.wikipedia.org/wiki/Hungarian_algorithm
• http://www.hungarianalgorithm.com/examplehungarianalgorithm.php

ripgrep cheat sheet

Incredible fast grep !

https://github.com/BurntSushi/ripgrep

It has faster results than ag.