john-shaffer

AWS announced Lambda durable functions today in a blog post titled "Build multi-step applications and AI workflows with AWS Lambda durable functions" [0]

[0] https://aws.amazon.com/blogs/aws/build-multi-step-applicatio...

Related story with much more detail and comments: https://news.ycombinator.com/item?id=44105878

Have you considered https://github.com/dolthub/dolt for your use case?

But Nix is the best way to build images for dockerc.

Mostly playing around with stacking "powerful" words:

  King Kong + Power Ranger = King Kong Ranger (first)
  Megazord + Power Ranger = Power Megazord
  Megazord + Power Megazord or Artzord + Megazord = Ultrazord
  Dragonzord + Art = Artzord (first)
  Groot + Mega Artzord = Grootzord
  Megazord + Grootzord = Gigazord (first)
  Godzord + Giga Artzord = Giga Godzord (first)
  Giga Godzord + Giga Titanic Gigazord = Giga Titanic Godzord (first)
  Giga Titanic Godzord + Mega Power Godzillazord = Super Giga Mega Titanic Power Godzillazord (first)

Trying to get Zebra was an interesting sequence.

  Tamer + Africa = Tamerlane (first)
  Tamerlane + Terror = Timur (first)
  Timur + Asia = Genghis Khan
  Genghis Khan + Bellerophon = Alexander the Great
  Alexander the Great + Unicorn = Bucephalus (first)
  Alexander the Great + Bucephalus = Horse
  Horse + Africa = Zebra

https://jobs.braveclojure.com/

Clojure itself actually loads pretty quickly, but almost every project has enough libraries to make loading the project take a few seconds.

  export LC_ALL=C
  nix-shell -I nixpkgs=https://github.com/NixOS/nixpkgs/archive/2322899a1fa85f6547004b2829af81e7b444f506.tar.gz -p openssh
  ssh -V
  OpenSSH_6.1p1, OpenSSL 1.0.0i 19 Apr 2012

So how do I install the old version next to the new version in ubuntu 34.04?

You would install Nix and run something similar to "nix run nixpkgs-23.11#openssh <address>"

This looks promising, but it doesn't work on personal accounts. I'm not ready to install it on my organization account just yet.

Can I expect complex caching actions like https://github.com/DeterminateSystems/magic-nix-cache to work as quickly as they do on GitHub?

Clarification on file duplication: DVC tries to use reflinks if the filesystem supports it, and falls back on copying the files. It can be configured to use hardlinks instead for filesystems like ext4 [0]. This improves performance significantly.

[0] https://dvc.org/doc/user-guide/project-structure/configurati...

DVC is slow because it stores and writes data twice, and the default of dozens of concurrent downloads causes resource starvation. They finally improved uploads in 3.0, but downloads and storage are still much worse than a simple "aws s3 cp". You can improve pull performance somewhat by passing a reasonable value for --jobs. Storage can be improved by nuking .dvc/cache. There's no way to skip writing all data twice though.

Look for something with good algorithms. Xethub worked very well for me, and oxen looks like a good alternative. git-xet has a very nice feature that allows you to mount a repo over the network [0]

[0] https://about.xethub.com/blog/mount-part-1

Performance with Docker is slightly worse, but it shouldn't be an issue for a long-running process. The main problem I've run into is that, by default, Docker logs will eventually fill the disk and crash the server. You have to change the logging system and then delete and recreate all of your containers, because there is no way to change the logging system for existing containers.

Thanks. I had no idea D2 was on switch, and it's on sale for $13! [1]

[1] https://www.nintendo.com/store/products/diablo-ii-resurrecte...

malli, specter, and calva are all less than ten years old. Clojure has seen a lot of progress in tooling and libraries.

IIRC, posts with more comments than votes are automatically penalized. It is #11 on the front page now, though.

Polylith does a good job of solving this: https://polylith.gitbook.io/polylith/

Have you had problems with Nix on macOS? Nix works great for me, but I can't use it much to deal with installs or synchronize dependencies because the devs on macOS can't get Nix running.

I have no affiliation, but I tried the free trial of their tool and I found that the Code Health metrics made a lot of sense. The files that it pointed out are definitely overly complex and more difficult to change than they need to be. But it gave perfect scores to some files with complex jobs that are better-designed. I recommend just giving it a spin on a codebase that you are very familiar with.

In production, I may only want one connection pool to a DB, and in that case global state is pretty much equivalent to passing state as an argument. Development in a Clojure REPL is a different story. I have one connection pool for the dev server, and a separate pool to run tests against. The test db is re-created from a template between each test run, without affecting the dev db at all. I can trivially have multiple test pools if I want to run tests concurrently.

I also have a separate service that the server makes calls to, which doesn't run on this server in production (it has its own production server), but does run in dev and test. Each dev/test system runs a separate instance of this service, which has its own separate connection pool(s), and setting this up was trivial.

Needless to say, failures are reproducible and meaningful. There is no mocking -- we test against real local services with real local DBs. (There are still some remote service calls which I'm slowly replacing, and some flakey, unavoidable remote dependencies in a few browser tests).

I didn't do anything special to make this possible other than naming the config files "service-name-config" instead of just "config". It is just the natural result of passing state in explicit arguments. The same is not true of global state.

Thanks for the explanation. What are some of the other techniques?

I just added a test case that importing org.apache.logging.log4j.core.lookup.JndiLookup throws a ClassNotFoundException. Any log4j2 class would work too.

Clojure is strongly typed and dynamically typed, not "untyped". Much of its core behavior is built on interfaces like ISeq.

It's not uncommon to use a spec library like clojure.spec or malli, whose benefits overlap those of static typing. I'm not sure if there is a measured improvement from their use, but they have either advantages like facilitating generative testing that do help one to write more correct software.

I have one of their borg accounts, which is a fraction of the normal price. https://www.rsync.net/products/borg.html

This is a good example of why dynamic vars are dangerous. They are just as perilous as global state, but are more surprising and more difficult to understand. Prefer passing explicit arguments in all cases. You don't have to even think about the behavior, and you'll never spend 8 hours tracking down a missing binding in a commit from 2018.

It's pretty easy to run embedded postgres on the JVM: https://github.com/opentable/otj-pg-embedded

The defaults create a temporary DB which is useful for dev & tests, but a pair of calls to .setCleanDataDirectory(false) and .setDataDirectory("...") will change that.

If you don't like the default postgres version, you may select one from https://search.maven.org/search?q=io.zonky.test.postgres or include your own postgres binary.

You might be just fine adding an unindexed tsvector column, since you've already filtered down the results.

The GIN indexes for FTS don't really work in conjunction with other indices, which is why https://github.com/postgrespro/rum exists. Luckily, it sounds like you can use your existing indices to filter and let postgres scan for matches on the tsvector. The GIN tsvector indices are quite expensive to build, so don't add one if postgres can't make use of it!

That appears to have been true for only about a month: https://groups.google.com/g/clojure/c/WI3ddZRK4Bg/m/RtJVt3IZ...

https://github.com/clojure/tools.deps.alpha/commit/c22ad46c6...

I found an old thread that examines some of the early usage of deps. Data > macros does indeed seem to be a driving force: https://clojureverse.org/t/combining-tools-deps-with-leining...

tools.deps makes better choices when dependency specs conflict, so I would suggest trying https://github.com/RickMoynihan/lein-tools-deps if you otherwise want to use lein, and get the best of both worlds.

By better, I mean:

Leiningen and Maven, when there is a conflict always pick the version that is closest to the root of the dependency tree; where as tools.deps always picks the newest.

I've used native-image both directly and indirectly. Directly to implement a Clojure-language authentication server which needed a small memory footprint. Indirectly through @borkdude's https://github.com/babashka/babashka which provides a native-image binary that can run much of the Clojure language.

We open-sourced some babashka code at https://github.com/staticweb-io/staticweb-open-wp/tree/maste... One major caveat: when I wrote that code, babashka didn't have any MySQL support, so I shelled out to the MySQL CLI. Later, I figured out how to compile the MySQL JDBC drivers with native-image and it's now available at https://github.com/babashka/babashka-sql-pods along with HSQLDB, SQL Server, Oracle, and Postgres drivers.