To add to lproven's point.

An article called "A Spreadsheet and a Debugger walk into a Shell" [0] by Bjorn (letoram) is a good showcase of an alternative to cells in a Jupyter notebook (Excel like cells!). Another alternative a bit more similar to Jupyter that also runs on Arcan is Pipeworld.

[0] https://arcan-fe.com/2024/09/16/a-spreadsheet-and-a-debugger... [1] https://arcan-fe.com/2021/04/12/introducing-pipeworld/

PS: I hang out at Arcan's Discord Server, you are welcome to join https://discord.com/invite/sdNzrgXMn7

The scipy/numpy to matlab is a good example. In my opinion it is on its way but in many places the timing is more like 2010-2013 where a lot of people knew python was the future but universities still used only Matlab.

I think the answer depends on the country: In places where the government uses QGIS it is like Blender. In places where ESRI has a stronghold it is like LibreOffice.

Mark Knol is a great generative coding artist: https://github.com/markknol/

Chris Randall is pretty awesome too: https://www.instagram.com/chris.randall.art/

Hey AJ, this is almost on topic, do you know of a more up to date version of the dataset you used on the blog post release for H3 v4.0.0 [1]? They stopped updating in Oct 2023. Thanks! [1] https://data.humdata.org/dataset/kontur-population-dataset

I don't. And maybe I should have emphasized "and have a data source" more, since its doing a lot of the heavy-lifting in my statement :)

It is a gui framework that allows you create terminals where you can detach any running process into another terminal.

Since it is a complete toolkit, you can have detachable applications where you send both code and state to a server and retrieve it from another device (like Apple's continuity).

In the end it is just a bunch of lua scripts talking to other components via /dev/shm and to other computers using a new protocol called a12://

I did not believe you and just typed it on OSX, half a minute later the app was ready for me to use.

nix run nixpkgs#pyspread [0/1 built, 3/113/132 copied (1311.8/1721.6 MiB), 280.4/300.7 MiB DL] fetching llvm-16.0.6 from https://cache.nixos.org

https://pasteboard.co/P1eh7B7W8C9R.png

I'll let Kyle chime in but I tested it a few months ago with millions of polygons on an M2 16GB of RAM laptop and it worked very well.

There is a library by the same author called lonboard that provides the JS bits inside JupyterLab. https://github.com/developmentseed/lonboard

<speculation>I think it is based on the Kepler.gl / Deck.gl data loaders that go straight to GPU from network.</speculation>

Check out devenv.sh from the Cachix people, it allows you to list stuff like pip for any language, including services / postgresql extensions:

   { pkgs, ... }: {
   services.postgres = {
    enable = true;
    package = pkgs.postgresql_15;
    initialDatabases = [{ name = "mydb"; }];
    extensions = extensions: [
      extensions.postgis
      extensions.timescaledb
    ];
    settings.shared_preload_libraries = "timescaledb";
    initialScript = "CREATE EXTENSION IF NOT EXISTS timescaledb;";
  };
   }

Interesting, but the word "containers" is scaring me. I wanted just a simple tool to download and install several libraries and not a full Docker/Kubernetes level system...

But it looks like a good choice for running tests in CI.

Hi! Devenv user here:

devenv.sh autogenerates Nix specifications of container images for each of the development environments you define with it, and exposes them in a Nix flake for you. But if you don't explicitly ask Nix to build those for you, it doesn't.

My team's most complex devenv environment passes through some packages from Nixpkgs, exposing them in the flake, defines 3 or 4 development environments ('devShells') and also exposed (and includes in some of those devShells) some custom packages that just live in that repo and not in Nixpkgs.

Our simplest just uses all built-ins and defaults, exposes no packages, doesn't have a custom flake... there's basically nothing to it. It just uses devenv/Nixpkgs built-ins to add OpenTofu with some Terraform plugins to the path and plugs a Terraform linter into the project's pre-commit hooks.

There is some support for running long-lived processes via process-compose, which is inspired by docker-compose, but we don't yet need it for anything so we don't use it. (In the past I've rolled my own solution for this with Nix, direnv, and supervisord. Today I'd probably just use devenv.)

What I love about devenv is how cleanly it integrates with the wider Nix ecosystem in a no-nonsense way, as well as its great docs. I like that it

  - it uses the Nix module system for configuration, based on a standard implementation (flake-parts) shared by other projects
  - what it builds in, i.e., pre-commit hooks integration, exists in a separate repo also usable on its own via flake-parts
  - the docs and the tool both support flakes-based setups, non-flakes setups
  - if you want to let devenv automagically set up a flake for you, you can, but you can also use most of its features with a handwritten flake.nix customized to your liking
  - while it exposes some configuration via yaml for simple uses, the full power of Nix is always available
  - it takes care of all the little details you'd have to deal with if rolling your own (e.g., garbage collection, direnv integration) in a sensible way

For me, as a Nix user, it does a good job of keeping simple use cases simple, it has low lock-in, it uses familiar configuration interfaces, and it doesn't have too much magic.

I hope that helps you get a sense of what using devenv is like for simple use cases as well as what the more complex stuff might look like!

I think containers are completely optional and it can install and run everything directly.

nix eco has project(s) which instead building full images just plug tiny shim linked into nix store. nix-snapshotter. fast and small. oci images spec allows to do nice thing with nix.

devenv has container support if you're looking for it, but you can completely ignore it if (like me) you don't care

One way to wrap your head around it is apt/systemd in a pip-like config file.

Imagine if we had said the same about Nginx. Let's evaluate things on technical merits, specially if they are using open source licenses we understand. In this case GPL v3.

Yes, imagine if we had said the same about Nginx. Now let's imagine now that we're saying those things in 2024, during the first major land war in Europe since WWII, in a context where state actors, if they are not already Jianing Tan, have enormous motivation to do so.

Now, let's put the risk at the root of the build system, and leave the lead devs in a country known to coerce, threaten, torture, poison and kill its dissidents.

That's a no from me, dawg. Look outside, it's not 2015 anymore.

I’m afraid these wars are going to kill open source.

Unfortunately… if that’s going to happen, I’d rather have it happen without first having huge security breaches.

I'm responding to their suggestion to travel to Moscow. FWIW I am very excited to see a rust impl of Nix focused on performance, and I am completely understanding that a person cannot pick their nationality (to some degree).