Quali sono le migliori librerie Haskell per rendere operativo un programma? [chiuso]

Se ho intenzione di mettere un programma in produzione, ci sono diverse cose che devo fare per poterlo considerare "reso operativo", ovvero funzionante e gestibile in modo misurabile e verificabile sia dagli ingegneri che dal personale operativo. Per i miei scopi, un programma operazionalizzato deve:

• Essere in grado di accedere a più livelli (es: debug, avviso, ecc.).
• Essere in grado di raccogliere e condividere metriche / statistiche sui tipi di lavoro che il programma sta svolgendo e sulla durata del lavoro. Idealmente, le metriche raccolte sono disponibili in un formato compatibile con strumenti di monitoraggio di uso comune come Ganglia , o possono essere modificate.
• Essere configurabile, idealmente tramite un sistema che consente di aggiornare le proprietà configurate nei programmi in esecuzione senza riavviare tali programmi.
• Essere distribuibile su server remoti in modo ripetibile.

Nel mondo Scala esistono delle buone librerie per gestire almeno i primi tre requisiti. Esempi:

• Logula per la registrazione.
• Metriche o struzzo per raccogliere e generare rapporti sulle metriche.
• Configgy o Fig per la configurazione.

Per quanto riguarda la distribuzione, un approccio adottato nel mondo Scala è quello di raggruppare il bytecode e le librerie che compongono il proprio programma con qualcosa come assembly-sbt , quindi inviare il bundle risultante (un "fat JAR") a server remoti con uno strumento come Capistrano che esegue comandi in parallelo su SSH. Questo non è un problema che richiede strumenti specifici per la lingua, ma sono curioso di sapere se tale strumento esiste nella comunità Haskell.

Probabilmente ci sono librerie Haskell che forniscono i tratti che ho descritto sopra. Vorrei sapere quali delle librerie disponibili sono considerate "migliori"; ovvero, che sono i più maturi, ben tenuti, comunemente utilizzati nella comunità Haskell ed esemplari delle migliori pratiche Haskell.

Se ci sono altre librerie, strumenti o pratiche per rendere il codice Haskell "pronto per la produzione", mi piacerebbe sapere anche di quelli.

Questa è un'ottima domanda! Ecco un primo taglio.

Essere in grado di accedere a più livelli (es: debug, avviso, ecc.).

hslogger è facilmente il framework di registrazione più popolare.

Essere in grado di raccogliere e condividere metriche / statistiche sui tipi di lavoro che il programma sta svolgendo e sulla durata del lavoro. Idealmente, le metriche raccolte sono disponibili in un formato compatibile con strumenti di monitoraggio di uso comune come Ganglia, o possono essere modificate.

Non sono a conoscenza di strumenti di reportistica standardizzati, tuttavia, l'estrazione di report dai +RTS -sflussi (o tramite flag di output di profilazione) è stata qualcosa che ho fatto in passato.

$ ./A +RTS -s
64,952 bytes allocated in the heap
1 MB total memory in use
 %GC time       0.0%  (6.1% elapsed)
 Productivity 100.0% of total user, 0.0% of total elapsed

Puoi ottenerlo anche in un formato leggibile dalla macchina:

$ ./A +RTS -t --machine-readable

 [("bytes allocated", "64952")
 ,("num_GCs", "1")
 ,("average_bytes_used", "43784")
 ,("max_bytes_used", "43784")
 ,("num_byte_usage_samples", "1")
 ,("peak_megabytes_allocated", "1")
 ,("init_cpu_seconds", "0.00")
 ,("init_wall_seconds", "0.00")
 ,("mutator_cpu_seconds", "0.00")
 ,("mutator_wall_seconds", "0.00")
 ,("GC_cpu_seconds", "0.00")
 ,("GC_wall_seconds", "0.00")
 ]

Idealmente potresti collegarti a un runtime GHC in esecuzione su un socket e guardare queste statistiche GC in modo interattivo, ma attualmente non è semplicissimo (necessita di un binding FFI all'interfaccia "rts / Stats.h"). Puoi collegarti a un processo usandoThreadScope e monitorare il comportamento di GC e threading.

Flag simili sono disponibili per la profilazione incrementale di tempo e spazio registrato , che può essere utilizzata per il monitoraggio (ad es. Questi grafici possono essere costruiti in modo incrementale).

hpcraccoglie molte statistiche sull'esecuzione del programma, tramite il suo Tixtipo, e le persone hanno scritto strumenti per registrare in intervalli di tempo il codice in esecuzione.

Essere configurabile, idealmente tramite un sistema che consente di aggiornare le proprietà configurate nei programmi in esecuzione senza riavviare tali programmi.

Sono disponibili diversi strumenti per questo, puoi ricaricare lo stato in stile xmonad; o passare al codice hotswapping tramite plugins* pacchetti o hint. Alcuni di questi sono più sperimentali di altri.

Distribuzioni riproducibili

Galois è stato recentemente rilasciato cabal-dev, che è uno strumento per creare build riproducibili (cioè le dipendenze sono definite e controllate).

• Per quanto riguarda la configurazione, ho trovato ConfigFile utile per i miei progetti. Lo uso per tutti i miei demoni in produzione. Non si aggiorna automaticamente.
• Uso cabal-dev per creare build riproducibili in diversi ambienti (locale, dev, collega-locale). In realtà cabal-dev è indispensabile, soprattutto per la sua capacità di supportare versioni locali con patch di librerie all'interno della directory del progetto.
• Per quello che vale, andrei con il ricaricamento dello stato in stile xmonad. La purezza di Haskell lo rende banale; la migrazione è un problema ma lo è comunque. Ho sperimentato con hsplugins e hint per il mio IRCd e nel primo caso si è verificato un problema di runtime GHC e nel secondo un errore di segmentazione. Ho lasciato i rami su Github per il successivo post mortem: https://github.com/chrisdone/hulk

Esempio di ConfigFile:

# Default options
[DEFAULT]
hostname: localhost
# Options for the first file
[file1]
location: /usr/local
user: Fred

Vorrei fare eco a tutto ciò che Don ha detto e aggiungere alcuni consigli generali.

Ad esempio, due strumenti e librerie aggiuntivi che potresti prendere in considerazione:

• QuickCheck per test basati su proprietà
• hlint come versione estesa di-Wall

Entrambi sono mirati alla qualità del codice.

Come pratica di codifica, evita Lazy IO. Se hai bisogno di streaming IO, allora vai con una delle librerie iterate come enumerator . Se guardi Hackage vedrai librerie come http-enumerator che usano uno stile enumerator per le richieste http.

Per quanto riguarda la scelta di librerie su hackage, a volte può essere utile vedere quanti pacchetti dipendono da qualcosa. Vedi facilmente le dipendenze inverse di un pacchetto puoi usare questo sito Web, che rispecchia l'hackage:

• http://bifunctor.homelinux.net/~roel/hackage/packages/archive/revdeps-list.html

Se la tua applicazione finisce per fare loop stretti, come un server web che gestisce molte richieste, la pigrizia può essere un problema sotto forma di perdite di spazio. Spesso si tratta di aggiungere annotazioni di rigore nei posti giusti. Profilazione, esperienza e nucleo di lettura sono le principali tecniche che conosco per combattere questo genere di cose. Il miglior riferimento per la creazione di profili che io conosca è il capitolo 25 di Real-World Haskell .