Arc Forumnew | comments | leaders | submitlogin
3 points by i4cu 161 days ago | link | parent

This is a surprisingly difficult question to answer, but here I go...

FYI cljs = clojurescript.

When Clojure first came out there was a core set of libraries that everyone flocked to:

1. Compojure (a routing library)

  - similar to arc's defop
https://github.com/weavejester/compojure

example:

  (defroutes app
    (GET "/" [] "<h1>Hello World</h1>")
    (route/not-found "<h1>Page not found</h1>"))
1a. Ring (a middleware library)

  - parses the web request and converts it into a hash-map of meaningful values.
  - similar to srv.arc
https://github.com/ring-clojure/ring

2. Hiccup (HTML Soup)

  -  similar to hmtl.arc, but uses a data structure to provide flexibility.
https://github.com/weavejester/hiccup

example:

  [:head
    [:meta {:http-equiv "Content-type"
            :content "text/html; charset=utf-8"}]
    [:title "adder"]
    [:link {:href "/adder.css" :rel "stylesheet" :type "text/css"}]]
Much of this came about when people read example blogs like this:

https://mmcgrana.github.io/2010/07/develop-deploy-clojure-we...

note: it's a 2010 article so some of it's outdated, but the idea would be the same.

At that time everyone was racing to make more robust web frameworks. Many of them were from people doing the above stuff only adding features. However, shortly afterwards cljs was released and another slew of web frameworks came out as people embraced writing web apps client side. Then again, shortly afterwards, Facebooks React became the new thing and advanced the idea of further separating out the data content from the UI composing for rendering. At this point data models (i.e. big hash-maps) and syncing that data to the UI became the new norm. And even since then more advanced frameworks came out, such as Fulcro, that further extend the data modelling & syncing features (https://github.com/fulcrologic/fulcro).

Through out all this many web frameworks became abandon-ware and now it's really hard for a newbie to make sense of which one to use. In my opinion:

1. If you want to do what Arc does (server side page generation) then use Compojure + Hiccup.

2. If you want to write basic client side cljs code there are dom libraries like:

- Dommy https://github.com/plumatic/dommy

- Domina https://github.com/levand/domina

These are fairly simple to use.

2a. If you want to write client side cljs code that takes advantage of React then use Reagent. https://github.com/reagent-project/reagent (Much better more interesting that Domina/Dommy)

If you have a desire to enter the more advanced data-model-UI-syncing arena where I would probably use Fulcro (but haven't). Note that these advanced frameworks like Fulcro expect you to know much more about state management / data modelling and it could be a steep learning curve for some.

I've been developing cljs web apps for over 4 years. Over these years I've tried some of the frameworks, but I ended up writing my own as none of them could do what I needed.

Is that helpful?

All of that may seem like too much, but remember you really only need Compojure + Hiccup to be where Arc is at.

Edit: I just noted that you know Datalog, so I think Fulcro is a good fit for you (see http://book.fulcrologic.com/#GraphDB).



2 points by hjek 161 days ago | link

> Is that helpful?

Yes! Thanks a lot for the write-up.

That Compojure example does look quite familiar and Arc-like, and looks like it can handle multipart post requests too[0].

I'd never heard of Fulcro before. Given what is often emphasised about Clojure, at first glance at the Fulcro docs I'm a bit surprised how often they mention state and mutations:

> The other very common case is this: You’ve loaded something from the server, and you’d like to use it as the basis for form fields. In this case the data is already normalized in your state database, and you’ll need to work on it via a mutation.[1]

Also, I'm too much into graceful degredation to ever go all out Cljs, unless it was for a phone app. But I find that it's often interesting to see how people do things in Clojure, even when not using that language, so I'll be giving those Fulcro videos a look.

[0]: https://github.com/whostolebenfrog/compojure-multipart

[1]: http://book.fulcrologic.com/#_initializing_in_a_mutation

-----

3 points by i4cu 161 days ago | link

> I'd never heard of Fulcro before. Given what is often emphasised about Clojure, at first glance at the Fulcro docs I'm a bit surprised how often they mention state and mutations:

Well things on the client side can be sometimes be mutable. No one gets around the fact the DOM is a mutable only object. But besides that, the Fulcro library has labelled one of their feature's a 'Mutation'. Which was probably a bad choice, but it has nothing to do with the immutability of the underlying cljs object that it uses for that "Mutation". You'll notice the example is using 'swap!'. That means it's modifying an atom; Where an atom is an interface to make changes to the immutable object it holds. So really 'swap!' takes the change request, constructs a new version the original thing held in the atom, with changes, then 'swap's it with the original item inside the atom. The original thing was never changed (no changes to existing slots in memory). Hence clojure's things are immutable, and they are in Fulcro too, accept when changing the DOM tree.

As for state that's mentioned all the time in Clojure :)

-----