biff VS honeysql

I definitely believe Clojure needs a rails. Not only will it help beginners get started, if it can help people get started faster and build fast like Django and rails do, I think it'll help more with adoption.

Biff and fulcro seems like they have a shot at this

Biff- https://github.com/jacobobryant/biff

Fulcro - https://github.com/fulcrologic/fulcro

Jacob is doing a fantastic job with https://biffweb.com/ If the Clojure community would focus more of its manpower on such projects, then I think we can make Clojure the obvious choice to start a software business, by saving an insane amount of time. And time is by far the scarcest resource in a startup.

If you can get away with not using React, I highly recommend Biff. It uses XTDB and Rum by default but they can be swapped out pretty easily for Postgres and Reagent. I'm planning to publish some docs on how to do that when I have a chance.

The best one of these imo is https://biffweb.com

I'm also really liking the strategy of the old-school is new again with sever side rendering serving actual HTML instead of JSON for certain things, using HTMX, an example can be found here: https://biffweb.com/

Take a look at Biff project https://biffweb.com/

+1 for Malli and XT! For the relevant parts of Biff, see the example app's schema and the transaction reference docs. Biff has its own transaction format which includes schema checks via malli and various other conveniences, and it gets translated into XT's lower-level transaction format. Might provide some inspiration at least.

Rum is used throughout, though mostly via middleware[1], so you (almost) never see any calls to `rum.core/render-static-markup`. But all of the hiccup-style data structures (`[:div "foo"]`, etc) do get rendered by Rum.

htmx doesn't render anything on the backend; rather it gives the frontend more ways to interact with the backend. e.g. say you make an inline form--htmx gives you the ability to display/submit that form without refreshing the entire page, but all the html that's sent to the frontend is still getting rendered first by Rum.

[1] See https://github.com/jacobobryant/biff/blob/6353c406adef034448... and https://github.com/jacobobryant/biff/blob/6353c406adef034448...

I recall using korma way back I and I don’t recall it being terrible but I would say https://github.com/seancorfield/honeysql has very much superseded it by this point… (but I can see how that might not be obviously clear if one is to look at superficial metrics like GitHub stars for example…)

Joins can certainly work in a data format like YAML. For an example, see Honey SQL from the Clojure community [0] (though without something to contrast strings like Clojure's keywords, you miss out on the automatic parameterization).

You mentioned moving JOINs around, so I'll mention that if represented as structured data, you can move any of the top level components around, so you could more closely follow the "true order of SQL" [1]. For example, I would love to be able to put FROM before SELECT in all or almost all cases. There's also being able to share and add to something like a complicated WHERE clause, where essentially all programming languages have built-in facilities for robustly manipulating ordered and associative data compared to string manipulation, which is not well-suited for the task.

Now don't get me wrong, I don't particularly care for YAML (though it doesn't bother me that much), but as someone who's done their fair share of programmatic SQL creation and manipulation in strings, not having a native way to represent SQL as data is a mistake in my opinion.

0: https://github.com/seancorfield/honeysql#big-complicated-exa...

In Clojure-land, we are also using HoneySQL [1] which has similar characteristics. You are still working within SQL semantics so it's a bit more complicated, but we are doing great complicated things with just maps, no API necessary.

[1] https://github.com/seancorfield/honeysql

using honeysql we can make structured queries as well

As someone else already pointed out, next.jdbc is good for database connectivity (for Postgres and beyond). For composing the queries themselves, I strongly recommend Honey SQL. It lets you represent queries themselves as normal Clojure data structures, just vectors and maps.

Perhaps you're looking for a way of arranging SQL as an AST represented by data structures (or objects) that can be fed to a compiler. HoneySQL[0] is one such implementation of this idea and it makes your general transformation trivial for Clojure programs. You don't need to mess around with string concatenation because you have a predictable and extensible compiler for data structures (which are themselves easily composable/transformable/storable with Clojure) that you can trust to do the right thing. If you're using some weird database or need an esoteric syntax, extending the compiler to your clause is easy to do[1].

[0] https://github.com/seancorfield/honeysql

[1] https://github.com/seancorfield/honeysql#extensibility

https://github.com/seancorfield/honeysql (write SQL without having to write SQL)

I've used it from Clojure, via HoneySQL, so no ORM, no danger of SQL injection. It was really wonderful!

https://github.com/seancorfield/honeysql

I used it to quickly iterate on the development of migration SQL scripts for a MySQL DB, which was running in production on RDS.

I might have switched to H2 DB later, because that was more compatible with MariaDB, but I could use the same Clojure code, representing the SQL queries, because HoneySQL can emit different syntaxes.