HackerTrans
TopNewTrendsCommentsPastAskShowJobs

jgrodziski

no profile record

Submissions

Rediscovering the Handcart

solar.lowtechmagazine.com
40 points·by jgrodziski·há 3 meses·14 comments

Artemis II is competency porn

lizplank.substack.com
51 points·by jgrodziski·há 3 meses·83 comments

The economics of language choice in the LLM area

felixbarbalet.com
3 points·by jgrodziski·há 4 meses·0 comments

The Great Transition

danielmiessler.com
2 points·by jgrodziski·há 5 meses·0 comments

What's Next for Developer Teams: How to Prepare Now

thenewstack.io
1 points·by jgrodziski·há 9 meses·0 comments

AI-Powered REPL with Clojure MCP, Next Generation Developer Experience

metosin.fi
6 points·by jgrodziski·ano passado·0 comments

Claude 3.7 meta-reflects on Clojure vs. Python

ooloi.org
3 points·by jgrodziski·ano passado·0 comments

Research Debt

distill.pub
3 points·by jgrodziski·ano passado·0 comments

Why Clojure?

gaiwan.co
314 points·by jgrodziski·ano passado·296 comments

Event Sourcing without the Hassle

vvvvalvalval.github.io
3 points·by jgrodziski·ano passado·1 comments

Treasure hunt: Golden Owl has been found after 31 years

en.wikipedia.org
1 points·by jgrodziski·há 2 anos·1 comments

Clojure macros continue to surprise me

tonsky.me
138 points·by jgrodziski·há 2 anos·27 comments

What's the Point (In Polygon)?

medium.com
1 points·by jgrodziski·há 2 anos·0 comments

Why we bet on Clojure?

defsquare.io
2 points·by jgrodziski·há 3 anos·0 comments

Matrices and Graph

thepalindrome.org
205 points·by jgrodziski·há 3 anos·45 comments

comments

jgrodziski
·há 12 meses·discuss
Yes definitely agree, I own the Rotring 600 and 800 pencil and they are fantastic, as already said the ballpoint version is dependant on the refill. The construction is sturdy and they feel very robust and heavy. But... I've recently transitioned to Pilot Capless fountain pen and it's night and day with the write feeling: https://www.pilotpen.eu/our-products/capless/ with ink bottle refill. The nib size is important, I found the medium too large and landed on the fine nib size.
jgrodziski
·há 3 anos·discuss
We also write about our choice of Clojure for application development here: https://defsquare.io/blog/why-we-bet-on-clojure
jgrodziski
·há 3 anos·discuss
Yes I agree, timbre and clojure.spec are great and I used them a lot, nowadays I move to μ/log and Malli for instance. My comment was to provide some guidance for someone outside of the Clojure community to navigate in the library ecosystem. I updated my comment to reflect that it's an opinionated take and just that.
jgrodziski
·há 3 anos·discuss
> - Incredibly slow

Almost as fast as Java, and for performance critic processes 99.9% of the time we bump on infrastructure performance problem BEFORE hitting the wall with Clojure (see https://clojure-goes-fast.com/blog/ for tips and tooling about performance)

> - Hosted on the JVM, so you're going to be dealing with Java eventually

For me it's a major selling point: JVM is battle tested and a wonder of engineering. The Java ecosystem richness is incredible (see tooling above for monitoring and profiling for an example). And the platform is constantly moving forward (see latest JDK with virtual threads, generational ZGC, etc.). And of course GraalVM... (https://www.graalvm.org)

> - No automatic tail call optimization because of the limitations of the JVM, so it feels like you're writing a mess of macros rather than real functional code

Never have been a problem and I don't see the point with macros, and code we write looks _very_ functional...
jgrodziski
·há 3 anos·discuss
The Clojure's approach is to favour libraries over frameworks. We use Clojure on various style of applications (mainly web and API based), hosted on widespread infrastructure technologies of Cloud Providers (Kubernetes, PostgreSQL, Kafka, etc.) and it's a breeze: here are our reasons for choosing Clojure https://defsquare.com/blog/why-we-bet-on-clojure

If you want to look at libraries where some people have settled, here are our _opinionated_ takes on libraries that we use on almost every project:

- HTTP: Ring is the de facto way to manage HTTP request (see https://github.com/ring-clojure/ring/wiki/Concepts) supplemented with various "Middlewares" for web-related concerns (security, logging, content encoding, etc. see https://github.com/ring-clojure/ring/wiki/Standard-middlewar...). Jetty and Aleph are common web servers (and https://github.com/clj-commons/aleph) that implement Ring interface.

- Routing: Reitit (https://github.com/metosin/reitit)

- Single-Page App: shadow-cljs for the build concerns (https://github.com/thheller/shadow-cljs), Reagent with Re-frame for complex/large app (https://reagent-project.github.io and https://github.com/day8/re-frame). Even if we now prefer using HTMX (https://htmx.org) and server-side rendering (Hiccup way of manipulating HTML is just amazing, https://github.com/weavejester/hiccup).

- Schema management: Malli (https://github.com/metosin/malli)

- Lifecycle management: Mount, Integrant or Component (https://github.com/tolitius/mount https://github.com/weavejester/integrant and https://github.com/stuartsierra/component)

- Config management: Aero (https://github.com/juxt/aero) and environ (https://github.com/weavejester/environ)

- Log: μ/log (https://github.com/BrunoBonacci/mulog)

- Time: https://github.com/juxt/tick

- Testing: https://clojure.github.io/clojure/clojure.test-api.html and Kaocha for the runner (https://github.com/lambdaisland/kaocha).

- Package and project management: tools.deps is simple and powerful (https://clojure.org/guides/deps_and_cli)

For infrastructure stuff (PostgreSQL, Keycloak, Solr, Kafka, etc.), just wrapping the underlying Java library or driver is often enough, and there are lots of wrappers for easing the integration. And we implement Hexagonal architecture style to put all of that in place.

Don't be afraid a libraries not moving a lot recently, it's a sign that the library is mature and battle-tested. Clojure is a joy to use every day :)