Fork me on GitHub

I’ve just released new version of Penkala (0.0.3) - a composable query builder for PostgreSQL. Now with the support for insert, update and delete queries

metal 18

hi @U050986L9 , thanks for bringing fresh perspective on sql to clojure community. I am grateful that Walkable is mentioned in penkala's readme. However, I think the statement "eschewing SQL and instead use EQL to write the queries" does not describe Walkable. I guess that's your experience with exoscale's esql, but esql and walkable are not the same


Walkable exposes EQL for clients, but also have an adaption layer (that are hidden from clients) where you can use s-expressions (something like honeysql) to build SQL constructs


I hope that clears the confusion. Anyway, congrats on the release


@U0E2YV1UZ thank you for letting me know. I’ve played around with walkable during the last year (and read the docs multiple times), and I completely missed the s-expressions part. Is that a new thing? I’ll update the readme and link to the s-expressions docs 👍


no, the feature is part of walkable's core design and has been around for two years

👍 3

thanks for your collaboration


I made a simple library that allow you to stop core.async go loops: (only deps.edn :sha at the moment):

clojure-spin 12
Dainius Jocas10:03:14

I've made a jackson-jq wrapper for Clojure. The intended use case is to embed jq scripting into GraalVM native-images.

🎉 18

Helper pack for core.async with focus on error propagation

🎉 18
Ben Sless14:03:48

Well if we're sharing core.async libraries, I'll share one I've been developing for a while: more.async: Small composable independent machines. Oriented towards building processing pipelines What is it trying to solve? I've seen too many times people reinvent the wheel at several points when building core.async processes: • producing into processing pipelines and consuming from them • batching • routing to channels • circuit breaking more.async is an attempt to solve those issues once and generically, instead of many times and ad-hoc.

👏 36
Ben Sless15:03:19

> last edited 2015 I had no idea that page even existed =/


I (very) recently had a change accepted to add more.async to

❤️ 9
Ben Sless15:03:41

😮 thank you!


Do you recommend not using periodically! and reductions!?

Ben Sless11:03:51

No reason not to use either, as both have their uses @U0HG4EHMH

Mathieu Corbin19:03:28

I'm working on a new stream processing engine in Clojure, inspired by Riemann, which can be used for monitoring for example. It's still a work in progress project but I opened the repo and did an article explaining the project:

❤️ 33
👌 6
Adam Helins20:03:58

Pas mal du tout! I remember discussing Riemann with you years ago on IRC and how restarting and loosing state was indeed a pity. Glad to see the groove is still going!

Jakub Holý (HolyJak)09:03:21

Very interesting, merci! Your mention of logging got me thinking. Currently we send errors to Sentry for incident management/alerting but it is easy to exceed our quota when there is some temporary problem and the same error keeps repeating thousands of times. So I would like to put something in the middle, between our app and Sentry, that would limit the number of "repeated events" that get through. That would require writing an adapter that would expose Sentry-like API (so the clients can be used unchanged) and turned the events into the format Mirabelle understands. Next, I would need to define an event "fingerprint" so that I could detect what events actually stem from the same error condition (I guess some combination of the message and stack trace) and thus make a "throttling window" for each unique error. Finally, a sink that would pass the events that were not filtered out to Sentry. My question is: Would that be a reasonable use of Mirabelle (or some future version thereof)? Thank you!

Mathieu Corbin22:03:27

@U0522TWDA It should be possible indeed. Adding sentry support should not be that difficult (it's just an http client). Mirabelle already supports the Riemann "throttle" stream, which only send one to downstream actions evey N seconds

Mathieu Corbin22:03:16

So imagine you compute a fingerprint and store it in a :fingerprint key in your event, you could do: (by [:fingerprint] (throttle 1800 ;; 30 min (push-io! :sentry)))

Mathieu Corbin22:03:28

like that, each "fingerprint" has its own throttle