@bbarker@mastodon.sdf.org

Adventurer in Haskell, Scala, Rust, and similar. Erstwhile computational biologist.

<a rel=“me” href=“https://mastodon.sdf.org/@bbarker”>Mastodon</a>

  • 0 Posts
  • 9 Comments
Joined vor 3 Monaten
cake
Cake day: Okt. 30, 2022

help-circle
rss

The tool is Nix, coupled with direnv, not “devenv” (to be clear).


Interesting, hadn’t heard of this. Reminds me of the SageMath (maybe they can be used together as they are both Python-based).

Also, there’s a CAS called Maxima that has a very long history, going back to 1968. It is written in a Lisp.


If anyone ends up working on this as an open source project, please post here, maybe we can find some contributors. I was thinking of using Lemmy for this purpose at work, which would help me get more familiar with it in general.


Sorry - I didn’t realize your original link was to the video and not the project. After watching it (good talk!), I found the clip in question. It seems like he is just saying that 96% of the codebase is functions (of any sort), not that 96% of the functions in the code are pure.


and 96% of it is pure functions

Thanks - I was just wondering how this somewhat precise statistic was obtained.

Otherwise, all that makes sense generally, though I tend to model logging as an effect in statically typed languages with effect systems. But I agree that it isn’t the most important thing!


I generally take your point, though I believe FP can be applied to most domains with some benefit - it is just that existing, prevalent FP languages may not always be well suited for the job. In HPC for instance, there are a few interesting options:

  • For both games and HPC, Futhark may be of interest: “Futhark is a small programming language designed to be compiled to efficient parallel code. It is a statically typed, data-parallel, and purely functional array language in the ML family, and comes with a heavily optimising ahead-of-time compiler that presently generates either GPU code via CUDA and OpenCL, or multi-threaded CPU code.”

  • Sadly I can’t find it right now, but there was research language designed with the idea of separating the implementation from the specification, in such a way that the implementation could still be verified to conform to the specification; the specification was much more than a typical function signature as I recall. Basically you would write the function specification in a functional style, and then be able to have multiple implementations (e.g. for different hardware) conforming to that specification. I want to say this was from Standford but may be wrong about that.


As an FP-fan interested in Clojure, how does one track if functions are pure in Clojure? I had assumed this was not possible, due to it not being statically typed (although I gather there is 3rd-party support for gradual typing).


Since this is an alternative front end for Lemmy, could someone simply host an instance of LemmyBB and point it to an existing instance of Lemmy?