# What is it about?
**URL:** https://clojureverse.org/t/what-is-it-about/5848
**Category:** Watercooler
**Created:** [April 26, 2020, 8:48am UTC](https://clojureverse.org/t/what-is-it-about/5848 "2020-04-26T08:48:14Z")
**Posts on this page:** 5
**Page:** 1
### Author:  [@daslu](https://clojureverse.org/u/daslu)
#### Post date: [April 26, 2020, 8:48am UTC](https://clojureverse.org/t/what-is-it-about/5848/1 "2020-04-26T08:48:14Z")
I got it wrong.
š
I thought Clojure was about being hosted and **leveraging the power of host platforms** such as the JVM and JS.
Not anymore.
Now it is about **reaching everything**. Interop with [the GPU](https://dragan.rocks/articles/18/Interactive-GPU-Programming-1-Hello-CUDA), [Python](https://github.com/clj-python/libpython-clj), [the unix shell](https://github.com/borkdude/babashka), [the Truffle languages of GraalVM](https://github.com/davidpham87/graalvm-rinterop) and [R](https://github.com/scicloj/clojisr) demonstrates that it can be everywhere. The same basic principles of simplicity can be brought to any platform. On one of the conversations, @joinr called it _ **"the ultimate glue language"** _.
š
I thought it mainly was about **persistent data structures**.
Yes, but . .
With [well-thought abstractions](https://github.com/techascent/tech.datatype/blob/master/docs/00-sequences-and-arrays.md), one [can also reach](https://github.com/techascent/tech.datatype) **arrays of primitive datatypes** inside and outside of the host platform, without losing simplicity and elegant grammar.
š
I thought it was about _ **lightweight data modeling** _, as I learned from [this post](https://programming-puzzler.blogspot.com/2013/12/clojure-vs-scala.html) of Mark Engelberg ā about having the power to do anything with JSON-like data structures, and using that to model everything.
It was about processing maps, maps of maps, sequences of maps, sequences of maps of maps, etc.
ā a fun alternative to the popular way of thinking in tables, common to spreadsheets, relational databases and [some programming communities](https://r4ds.had.co.nz/tidy-data.html).
I thought it was still [a question](https://clojurians.zulipchat.com/#narrow/stream/151924-data-science/topic/what.20is.20a.20dataset.3F/near/183702270), whether these two ways could be in harmony.
Not any longer.
[tech.ml.dataset](https://github.com/techascent/tech.ml.dataset) answers the question by bringing efficient **table processing** to Clojure. Also, as @cnuernber recently [announced](https://clojurians.zulipchat.com/#narrow/stream/151924-data-science/topic/tech.2Eml.2Edataset/near/194609499), it allows to [seamlessly combine it](https://clojurians.zulipchat.com/#narrow/stream/151924-data-science/topic/datasets.20of.20strange.20shapes/near/194621094) with your beloved habits of working with sequences of maps, sequences of maps of maps, etc. This is may be the first time these two paradigms can live in such harmony that they are actually **seen as the same thing**.
š
I thought Clojure was about managing values and identities, and working with **session state** in a sensible way.
But it will be more than that.
Recent discussions with @generateme taught me that we can think beyond the single session, and use the same ideas of value and identity **across sessions**. Hopefully we will discuss that here further soon.
š
I thought it was about leveraging the power of **the REPL, the text editor and s-expressions** , combined in a way that practices the Lisp tradition of **dynamic exploration**.
But of course, these are also connecting to the visual world.
This is not new in the Clojurescript scene, where the REPL and the editor can be combined with a the browser in a live-reload experience.
What about backend Clojure?
There are some promising, actively developed [libraries](https://scicloj.github.io/pages/libraries/#literate_programming_and_data_visualization) for **data visualization and literate programming**. This is not new either, as notebooks such as [Gorilla REPL](http://gorilla-repl.org/) have been here for years.
What still remains to be figured out (I think) is how to tightly connect notebook interaction with a decent REPL and editor experience. But there are [some ideas](https://github.com/scicloj/notespace/issues/7#issuecomment-604210939) in that direction, suggesting how **we can have both at the same time**. More on that, soon.
On another direction, there are some [neat ways](https://github.com/applied-science/emacs-vega-view) to have **visualizations inside your beloved REPL and editor** , and they [seem to be fun](https://twitter.com/KimmoKoskinen/status/1247603600450355202).
š
I thought it was about **decomplecting** problems and solutions into small, composable functions and libraries.
But it is more than that.
We are seeing beautiful examples where kind people reach out to work together and have tight collaboration across libraries, looking to build **a coherent ecosystem**.
See, for example, [this discussion](https://clojurians.zulipchat.com/#narrow/stream/151924-data-science/topic/rendering.20charts.20in.20notespace/near/192924902). Six library authors working on `vega`/`vega-lite` rendering are patiently mapping the tradeoffs across their solutions, seeking agreement on a common foundation.
As @teodorlu recently explained to me, even if lots of very different approaches coexist here, this community might be **overcoming The Curse of Lisp**.
š
The developments of the last few months made me realize that Clojure was not about what I had thought it was about.
In this short list, I tried to share some links to conversations that made that understanding sink, for me.
---
### Author:  [@mauricioszabo](https://clojureverse.org/u/mauricioszabo)
#### Post date: [April 26, 2020, 4:27pm UTC](https://clojureverse.org/t/what-is-it-about/5848/2 "2020-04-26T16:27:08Z")
> [@daslu](#):
>
> What still remains to be figured out (I think) is how to tightly connect notebook interaction with a decent REPL and editor experience
Iām trying to work on this direction with Chlorine for Atom (and Clover, for VSCode). I think very soon, Iāll merge this code: [repl-tooling/test/repl\_tooling/editor\_integration/interactive\_test.cljs at ae78fd6e6b5a0f97a71acd4dcc76da93aa8bc545 Ā· mauricioszabo/repl-tooling Ā· GitHub](https://github.com/mauricioszabo/repl-tooling/blob/ae78fd6e6b5a0f97a71acd4dcc76da93aa8bc545/test/repl_tooling/editor_integration/interactive_test.cljs)
What it means is that _anyone can add_ ārenderersā for evaluation results. What this means in practice is that you can, with a custom command, send a code to Clojure (or ClojureScript, or Clojerl, or Joker, or Babashka) and get back a result that renders as pure HTML. Even more, you can interact with these results: on clicking/hovering/any HTML handler, a command can be sent to Clojure and the result be reflected on the ārendererā.
Itās still on the very early stages, but Iāll already implement some integrations on it, so it can be battle-tested for real š
---
### Author:  [@hlolli](https://clojureverse.org/u/hlolli)
#### Post date: [April 27, 2020, 5:16pm UTC](https://clojureverse.org/t/what-is-it-about/5848/3 "2020-04-27T17:16:42Z")
It would be a dull language if everyone had the same goal. I think the richness of Clojure is that users are so varied, with different interests, background and ofc personalities. It sounded bit ādisappointingā until I read ābut it is more than thatā, which is exactly how I feel.
---
### Author:  [@Jponline](https://clojureverse.org/u/Jponline)
#### Post date: [May 17, 2020, 4:45pm UTC](https://clojureverse.org/t/what-is-it-about/5848/4 "2020-05-17T16:45:14Z")
First of all, brilliant post.
For me was always about syntax and DSL. Clojure is a useful lisp, and even though I havenāt write a single macro until now, Iām comfortable with the possibility to write. And besides that I can benefit with its existence because others create libs with great api.
I say DSL (Domain Specific Language) because Clojure facilitates to create the vocabularies and abstractions you want. It doesnāt try to limit devs in favor of a false protection as other languages do. This is why I donāt like strongly typed languages, professional devs should be able to choose to use types where it make sense, optionally as Clojure allow.
I say more about languages and abstractions in a post [https://github.com/JpOnline/Blog/blob/master/language.md](https://github.com/JpOnline/Blog/blob/master/language.md)
---
### Author:  [@system](https://clojureverse.org/u/system)
#### Post date: [November 16, 2020, 4:45am UTC](https://clojureverse.org/t/what-is-it-about/5848/5 "2020-11-16T04:45:15Z")
This topic was automatically closed 182 days after the last reply. New replies are no longer allowed.