RxJS è l’acronimo di Reactive Extension for Javascript, è una libreria che si occupa di poter gestire in maniera molto semplice chiamate asincrone di qualsiasi tipo, per poter costruire programmi con interfaccia molto più “reattive”. L’idea di fondo è quella di eseguire le varie operazioni in maniera asincrona, e la libreria si occupa poi di riconciliare tutte le chiamate con i relativi programmi di gestione della risposta, in questo modo l’interfaccia non risulta bloccata sull’attesa della risposta al click del mouse su un pulsante, ma può proseguire la gestione degli eventi dell’interfaccia. Chi utilizza Angular, utilizza già questa libreria, forse neanche senza saperlo, per eseguire le chiamate alle WebAPI dell’applicazione: infatti i vari tool automatici di gestione delle WebAPI utilizzano RxJS per creare oggetti ad più alto livello, che utilizzano alla base RxJS. Un ottimo libro per esaminare a fondo questa libreria è RxJS in Action di Paul P. Daniels e Luis Atencio, il libro copre la versione 5 della libreria. Sarebbe utile conoscere i fondamenti della programmazione funzionale in Javascript prima di affrontare la lettura del libro, ma non è strettamente necessario. Il libro mostra con dovizia di esempi, come l’utilizzo della libreria renda semplice coinciso e chiaro la realizzazione della sincronizzazione di operazioni complesse, che richiederebbero complicate e oscure routine di programmazione classica.

La programmazione funzionale sta diventando sempre più importante nel mondo dello sviluppo, sopratutto quello Web. Un buon libro che affronta l’argomento utilizzando come linguaggio Javascript è il libro di Michael Fogus Javascript Functional pubblicato da O’Relley. Nel libro vengono affrontati i vari aspetti della programmazione funzionale, e poi vengono declinati in applicazioni Javascript. La libreria funzionale di riferimento utilizzata per gli esempi è Underscore.Js, ma per chi sviluppa applicazioni Web dovrebbe essere noto che JQuery, la regina delle librerie Web, è pienamente aderente ai dettami della programmazione funzionale.

If you have a pc with double (or more) monitor, with different DPI scale settings, you may have experienced fonts blurry in Visual Studio 2017 or Sql Manager. I have followed different solution proposed here. But the only tha worked form me is this.

12-07-2018

Too beautiful to be true, with the latter settings  VS Debugger do not work anymore!

13-07-2018

The definitive solution here.

 

Un modo divertente per imparare a programmare Codewars, sfide basate sulla soluzione di enigmi di programmazione, nei più disparati linguaggi di programmazione. 

In the book From Bacteria to Bach and Back by Daniel Dennet there is this note:

Four people come to a river in the night. There is a narrow bridge, and it can only hold two people at a time. They have one torch and, because it’s night, the torch has to be used when crossing the bridge. Person A can cross the bridge in one minute, B in two minutes, C in five minutes, and D in eight minutes. When two people cross the bridge together, they must move at the slower person’s pace. The question is, can they all get across the bridge in fifteen minutes or less?

This is a well know crossing problem like wolf cabbage and goat problem. Many of this problem are solved by simple Prolog program. But now i want solve this problem with a functional language: F#. A simple solution is (based on this):

open System

//cambia per trovare soluzioni in tempi diversi
let MAX_TIME = 15

type Person = 
  | Person of string * int

type Direction =
  | L
  | R

type Move =
  | Move of Direction * Person list

//estende il modulo List
module List =
  let rec combinations items =
    [
      match items with
      | [] -> ()
      | x::xs ->
        for y in xs do yield x, y
        yield! combinations xs
    ]

let rec Solve cost moves atStart atEnd dir =
  seq {
    if cost > MAX_TIME then ()
    elif Set.isEmpty atStart then yield cost, List.rev moves
    else
      match dir with
      | L ->
        for Person(_, time) as person in atEnd do
          let move = Move(dir, [person])
          yield! Solve (cost + time) (move :: moves) (Set.add person atStart) (Set.remove person atEnd) R
      | R ->
        let combinations = List.combinations (Set.toList atStart)
        for (Person(_, time1) as person1), (Person(_, time2) as person2) in combinations do  
          let move = Move(dir, [person1; person2])
          let persons = set [person1; person2]
          yield! Solve (cost + (max time1 time2)) (move :: moves) (atStart - persons) (atEnd + persons) L
  }      

let Persons =
  set [
    Person("A", 1)
    Person("B", 2)
    Person("C", 5)
    Person("D", 8)
    //Person("E", 1)
  ]

Solve 0 [] Persons Set.empty R
|> Seq.iter (printfn "%A")

 

Executing the program yield the following output (can be executed as is in LINQPad):

(15,
 [Move (R,[Person (“A”,1); Person (“B”,2)]); Move (L,[Person (“A”,1)]);
  Move (R,[Person (“C”,5); Person (“D”,8)]); Move (L,[Person (“B”,2)]);
  Move (R,[Person (“A”,1); Person (“B”,2)])])
(15,
 [Move (R,[Person (“A”,1); Person (“B”,2)]); Move (L,[Person (“B”,2)]);
  Move (R,[Person (“C”,5); Person (“D”,8)]); Move (L,[Person (“A”,1)]);
  Move (R,[Person (“A”,1); Person (“B”,2)])])

So the puzzle have two equivalent solution.

Playing with set of Persons and MAX_TIME constant, is possible to explore solution for different problem.

Keras è una libreria per il deep learning che può utilizzare TensorFlow, CNTK o Theano come motore di calcolo. CNTK è la libreria Cognitive Toolkit di Microsoft. Tutti i framework citati lavorano nativamente con Phyton.

Consider this pseudocode:

/*
	TData tabele of data to elaborate
*/
ConcurrentQueue<Exception> exceptions = new ConcurrentQueue<Exception>();
Parallel.ForEach(TData.AsEnumerable (),row =>
            {
                try
                {                    
                    using (WorItem p = new WorkItem(row,connectionstring))
                    {                        
                        p.DoWork();                        
                    }
                }
                catch (Exception ex)
                {                    
                    exceptions.Enqueue(ex);
                }
            });

Inside class WorkItem.DoWork, there are some database read with custom tableadapter and one finally write of results to db. The code inside DoWork code unexpectedly fail with error “Timeout expired” or “Failed to activate rows constraints…”. The failure is random. TData table contains about 50k rows. The code is executed on machin with 48 processors, connection pool contains between 20-30 concurrent pooled connection. The failure do not depends on the row, it’s totally random. If for some row i get some strange error, i the program run for that single row, no error is generated. So what to do to correct this error?

Solution 1:  disable connection pool. The problem is solved, but performance are very poor. Run time goes from 2 minutes and 30 seconds, to 16 minutes. Not good.

Solution 2: connection pool for every WorkItem object. In Ado.Net connection pool depends on connection string, so if you modify every connection for every object, connection pool is for object scope. But how modify the connection string on object basis. In connectionstring options there is App option. This option have no pratical effect, the only purpose of this option is that if you enlist the connection on the db server with sp_who, this name is shown as property of the connection. So if you modify the connection with some connectionstring=connectionstring+”App=”+hash(row), the connection pool occurs on per object basis. The drawback of this solution, is that in the destructor of the WorkItem objec (either with Finalize or Dispose) the connection pool must be cleared, with the simple call: SqlConnection.ClearPool(conn);. With this solution the excution time is more or less the same with unique connection pool. Connection pool size grows to 60-70 concurrent pooled connection.

Udate 3-5-2017

Solution 2 is not sufficient, in some heavvy load hour, the connection problem still is there. Be best solution is to open a single connection for every object, open the connection at the first use, en close the connection at Dispose of the WorkItem instance.