speaking about notebooks, there is also this one: https://hacks.mozilla.org/2019/03/iodide-an-experimental-tool-for-scientific-communicatiodide-for-scientific-communication-exploration-on-the-web/
and this one: https://nextjournal.com/
both interesting approaches
iodide is based on webassembly
nextjournal has some functional programming ideas behind:
The good news is that I believe that it is possible to fix computational reproducibility by applying a principle of functional programming at the systems level: immutability (which is what we're doing at Nextjournal). I will show how applying immutability to code, data and the computational environment gives us a much better chance of keeping things runnable in a follow-up post.
^^
show some love
@ocramz thanks! this place is full of surprises. the only accelerate I knew before now is https://developer.apple.com/documentation/accelerate , now I know acceleratehs, too cool :D
@complyue :) yeah sorry for not elaborating earlier, I was on my mobile. http://hackage.haskell.org/package/accelerate does really a few things and I'm not too qualified for describing them in detail, but one of these used to be rewriting high-level Haskell array programs in terms of predefined Cuda C splices, which are then executed on the GPU. Nowadays IIUC this is subsumed by compiling to LLVM intermediate representation : https://hackage.haskell.org/package/accelerate-llvm-ptx
there are some actual experts lurking around here, such as the main author @tmcdonell and one of the core LLVM-Hs contributors @cocreature
there's also a whole gitter channel dedicated to AccelerateHS : https://gitter.im/AccelerateHS/Lobby
@dmjio speaking of, I was looking at the API docs, and was puzzled by the use of unsafePerformIO in the wrapper functions e.g. : https://hackage.haskell.org/package/arrayfire-0.1.0.0/docs/src/ArrayFire.FFI.html#op3 ; wouldn't it be better to catch the FFI error codes and convert them into a Haskell sum type?
sorry, the problem (at least IMHO) is here: https://hackage.haskell.org/package/arrayfire-0.1.0.0/docs/src/ArrayFire.Exception.html#throwAFError
sure, it's possible to
catch an AFException, but I think the "pure" return types in the main API are misleading
@complyue (and other people interested in large-scale data visualization in the browser); I just saw mention of https://github.com/uwdata/falcon from one of the Vega folks
looked at falcon, about the data size it handled:
10M flights in the browser and ~180M flights or ~1.7B stars when connected to OmniSciDB (formerly known as MapD)
make me remember that at a time about months ago, I'd had to increase chrome's heap size to around 12GB to visualize one of my dataset (with BokehJS frontend and golang backend), as even the 64-bit version of chrome has a default heap size limit around 3.5GB:
performance.memory.jsHeapSizeLimit/1024/1024/1024
3.501772880554199seems they haven't hit this limit, while Bokeh already exceeded.
Hi guys, I and a few people started a room for pro/semi-pro Haskellers to discuss architecture of purely functional programs, mostly how to deal with effect composition frameworks (be it via raw monad stacks, free monads/applicatives, mtl, extensible-effects, polysemy, etc) which one is the best and interoperate between different libs written in different frameworks.
Its goal is to be "Effect composition for the rest of us": we want to have a focus on practical intermediate to advanced stuff (ie. remain accessible for those who don't know/want to know about coyoneda lemma or right-kan adjustments)
Ideal scenario: we determine the best effect composition pattern to rule them all and take over the pure FP world
Good enough scenario: we produce insights, use cases and material (or just discussions) about which way to best address effect composition in such specific scenarios and how to deal with interop between frameworks
Its goal is to be "Effect composition for the rest of us": we want to have a focus on practical intermediate to advanced stuff (ie. remain accessible for those who don't know/want to know about coyoneda lemma or right-kan adjustments)
Ideal scenario: we determine the best effect composition pattern to rule them all and take over the pure FP world
Good enough scenario: we produce insights, use cases and material (or just discussions) about which way to best address effect composition in such specific scenarios and how to deal with interop between frameworks
You can join the public community room https://gitter.im/pure-fp-architects/community if you are interested, and just drop a line if you are interested. The actual room is invite only
that's alright though, there's a strong selection bias for interesting people :)
I almost succeeded in distributing custom GHC by source with Nix, but met an annoying problem, any tip is appreciated: NixOS/nixpkgs#73443
data haskell community
I was talking with the author of massiv https://github.com/lehins about making some benchmarks for every Haskell array library (CPU + GPU). It seems you guys have done that already here: https://github.com/DataHaskell/numeric-libs-benchmarks
We don't know where to house a repo like this, and were wondering if we could contribute / work with people here to make a repo like this (even if that means contributing to the existing repo).
but like, I was gonna make all these nix scripts to build accelerate, massiv, hmatrix, arrayfire into one giant kahuna repo, then run the benchmarks on AWS, scp the results to some s3 bucket
hey @dmjio , when it comes to low-level array functions there's this : https://github.com/haskell-perf/sequences
and @Magalame started https://github.com/Magalame/fastest-matrices
the
numeric-libs-benchmarks repo is very incomplete wrt fastest-matrices