reflex-platform VS nix

We used reflex-frp, so our app was a webview that worked on localhost and Android. The docs say it also works on iOS but we don't have an iPhone.

The process was learning Functional Reactive Programming, then learning reflex-frp, then getting a contract with obsidian (creators of reflex) for one hour a week where we could ask questions.

( https://github.com/reflex-frp/reflex-platform )

We had a grant requirement to create a phone client for Tahoe-LAFS, a Python application with a bunch of dependencies, including ZFEC, a forward error correction library.

( https://tahoe-lafs.readthedocs.io/ )

( https://github.com/tahoe-lafs/zfec/ )

We needed bug for bug compatibility with the Python codebase, so I ran Tahoe on localhost and tested the Haskell client against the Python server. We used servant to build the API, since it builds both client and server side from the same description.

( https://hackage.haskell.org/package/servant )

The type classes do take a toll on performance, but in reflex-platform we change GHC's default flags to make the situation a lot better. It's still not ideal, but our performance winds up being OK for real applications. The most important part is that the performance scales reasonably well as the application grows. It might probably be good at some point to use backpack instead of a typeclass so that specialization can be enforced - though I'd prefer if GHC gave a way to just force specialization more effectively.

Obelisk / reflex-platform contain nix-based solutions to building Haskell code for mobile, so you might be interested in checking out how they do it (or just using them).

In this series of posts, we will describe how a Haskell web application can be developed using reflex-platform. reflex-platform offers reflex and reflex-dom packages. reflex package is the Haskell implementation of Functional reactive programming (FRP). reflex-dom library contains a large number of functions, classes, and types used when dealing with DOM. The packages are separated as it is possible to use the FRP approach not only for web-development. We will develop theTodo List application that allows carrying out various manipulations on the task list.

reflex-platform

To clarify the situation, the canonical way to develop reflex-dom projects is to start from the reflex-platform. See here: https://github.com/reflex-frp/reflex-platform/blob/develop/docs/project-development.rst

This might also be coming from the tests of the library (even if they can run in the browser, their tests might not). You can disabled tests using an overrides attribute in project.nix (if using reflex-stone). You can see what it should look like here : https://github.com/reflex-frp/reflex-platform/blob/develop/project/default.nix#L79. You should add this attribute at the same level where "useWarp = true;" is. This should then have lines like "diagrams = pkgs.haskell.lib.dontCheck super.diagrams;" for example if you want to disable the tests for the diagrams package.

then you compile to js using ghcjs like this, then closure compile and gzip it to get the size way down. Then it just becomes a normal script you include wherever you need it.

(Nix itself is slowly chugging along with Windows via MinGW - https://discourse.nixos.org/t/nix-on-windows/1113/108 and https://github.com/NixOS/nix/issues/1320 , for example.)

Nix is a cross-platform package manager. It uses the nix programming language. Nix and NixOs are often used in the same context, but while the first is a package manager, the latter is a linux distribution based on nix.

Today I want to talk to you about Nixos. What is it? Nixos is a declarative and reproducible OS, partly taking the words used on their own page. What does that mean?

Software developers often want to customize:

1. their home environments: for packages (some reach for brew on MacOS) and configurations (dotfiles, and some reach for stow).

2. their development shells: for build dependencies (compilers, SDKs, libraries), tools (LSP, linters, formatters, debuggers), and services (runtime, database). Some reach for devcontainers here.

3. or even their operating systems: for development, for CI, for deployment, or for personal use.

Nix provision all of the above in the same language, with Nixpkgs, NixOS, home-manager, and devShells such as https://devenv.sh/. What's more, Nix is (https://nixos.org/):

- reproducible: what works on your dev machine also works in CI in prod,

- declarative: you version control and review your configurations and infrastructure as code, at a reasonable level of abstraction,

- reliable: all changes are atomic with easy roll back.

Hopping from one distro to another with a different package manager might require some time to adapt. Using a package manager that can be installed on most distro is one way to help you get to work faster. Flatpak is one of them; other alternative are Snap, Nix or Homebrew. Flatpak is a good starter, and if you have a bunch of free time, I suggest trying Nix.

- it reduces bloat, because you can generate an environment or OS image with only the software needed to run a specific program or service

My guess is that a big efficiency gain would come from the second point, because you don't waste CPU on code that you don't use.

Does this make sense? Has anyone explored this?

[0]: https://nixos.org

1) Setting up the development environment - I currently use devcontainers for most things, but may also dig into nix -> isolated, portable, repeatable development environment 2) Exploring Echo - understand routing, requests, response, etc. 3) Incorporate Templ - integration with Echo, template composition, etc. 4) Integrating TailwindCSS - config for use with Echo/Templ, development cycle, deployment, etc. 5) Add in HTMX - endpoints, template structure, concepts, etc. 6) hyperscript for interactivity - client side interactivity

"Your greatest challenge lies ahead -- and downwards..."

Oh, wait a second, my bad, that's the quote on the box cover for Zork I: (

https://upload.wikimedia.org/wikipedia/en/a/ac/Zork_I_box_ar...

https://en.wikipedia.org/wiki/Zork

)

What you really wanted was a link to where you could download Nix/NixOS -- and/or learn more about it!

Here ya go!

https://nixos.org/

"Your greatest challenge lies ahead -- and downwards..."

:-) :-)

I say all of the above in the spirit of humor -- and as a NixOS user and fan!

(But yes, there is a learning curve to it, so yes, learning Nix/NixOS could be a challenge!)

((But you're a bright person, you have Google and ChatGPT to assist you, and you like challenges!))

Semi-related, I would recommend to anyone who is a Linux native to try to find some kind of "minimum viable setup" that is really really easy for you to run out of VirtualBox or Parallels or something for this reason. No matter where you go, you know you can have a suite of tools which work just as you want them to there. Being able to tear it down and rebuild it quickly is also a great way to deal with debugging certain kinds of problems of the "it runs/doesn't run on my machine" category.

How you do this is of course up to you. At one end of the spectrum is just relying on your memory. At the other end is using NixOS https://nixos.org/ to get fully reproducible builds anywhere you go. Between these are a vast field of options. I know a guy who maintains an Ansible file set to `host: localhost` which installs everything he wants from that file. For me, I just stick with the latest Ubuntu version and maintain a few shell scripts [1] that install 80% of what I like to have on a new install.

If you like the scientific approach, you can install something like https://atuin.sh/ and do some statistics on what programs you actually run most frequently based on your long term shell history.

[1]: https://github.com/hiAndrewQuinn/shell-bling-ubuntu

See https://github.com/NixOS/hydra/issues/838 for making content-addressed derivations supported by hydra.nixos.org. At that point, we can actually try out the XP feature at scale.

Also see https://github.com/NixOS/nix/issues/8919 for this accepted RFC

Once those things are done, we can get back to merging in the IPFS code.

Now that there is an Nix team and I am on it, there is much, much less of an issue of these experiments being caught in limbo :).