Because they’re really time consuming

As someone who used to do a lot of conference talks around the world for about a decade, I can totally support that! I think most people (who haven't given conference talks) have no idea just how much work goes into them -- and also how it can kind of "spoil" the conference for you, until you've given your talk (so an end-of-conference keynote is, in many ways, much worse than a regular talk during the conference).

I stopped speaking at conferences in 2013 and I have really enjoyed attending conferences since then! 🙂

(although I keep promising myself I'll submit a talk to Conj one year!)

Please do Sean! I, for one, would be interested :)

@UC1DTFY1G what talks would you want Rich Hickey to actually give? I still get value revisiting many of the videos Rich has done over the years and its not immediately obvious to me what new topics would be beneficial. As others have stated, preparing a talk can take many days or many weeks to prepare. The live broadcasts on Clojure I did for an hour each week for Practicalli would take the whole week to prepare and most would have benefited from more preparation. Personally, I would rather Rich focused on stewarding Clojure itself, especially as more and more of the Clojure community are sharing their experiences.

@U05254DQM Nothing specific. Sends out a good message if the creator of the language makes a public appearance once in a while. That's all. Some people actually ARE sheep who'd rather follow someone 😄 (myself included sometime) For those who lack the skills to practically grok everything by themselves, it's a good heuristic to follow others who are respected. (This is true no matter how much I dislike this fact)

There are many people in Cognitect (now NuBank) who regularly give talks, as well as a hugely diverse community. I think its highly dubious for one person to be seen as the only respected source for a language and personally this would be one thing that deters me from that language. Clojure is an established language and used by those who appreciate its qualities and spend time investing in it. I think the software industry would be much more mature if everyone had the opportunity to meaningfully consider the language(s) they use.

As useful as taps are, which is very

For me, Portal is a core part of my workflow. I use VS Code/Calva with the Portal extension (so it runs inside VS Code) and I have my actual REPL hidden and rely entirely on Portal. The ability to use datafy/`nav` on complex data structures as well as multiple ways to visualize that data is immensely powerful.

I really need to do some screencasts of how I work since it's a lot easier to show than to tell...

Even the most basic aspect: showing hash maps and vectors as tables is a huge comprehensibility boost over plain text in a REPL.

@U04V70XH6 One of the most difficult parts of learning Clojure for me has been getting the correct dev setup. I think the REPL workflow and integrating tools like these should be front and center. Instead I found out these stuff slowly. Anyway, please do a screencast. That'd really help me and I guess many others.

It doesn't help that I'm stuck on Windows either

Clojure seems unaware that Windows exists

@U04V70XH6 One question. I need to tap> something to send it to portal right? If I just Ctrl+Enter in calva, that form gets sent to repl and evaled. Is it possible to have this kind of setup with portal without explicitly adding tap>s all over the code?

I do all my dev on Windows -- both at work and for my OSS projects (two separate machines). I use WSL2 for all the Clojure stuff and run VS Code on Windows.

@U04V70XH6 Yeah, I realized I need WSL2 way too late 😄

My https://github.com/seancorfield/vscode-calva-setup repo has my VS Code / Calva / Joyride / Portal setup, for the most part, and my https://github.com/seancorfield/dot-clojure repo has my aliases and my dev.clj which starts my REPL (and patches clojure.tools.logging if Portal is on the classpath).

I use the Portal middleware for nREPL so all my evals are tap>'d and sent to Portal, although I have some customization around that so evaluations that invoke tap> directly are handled differently. My Calva customREPLCommandSnippet settings are in my vscode repo in an EDN file and that's where all my tap>-related magic happens.

I use Joyride to open VS Code's Simple Browser with http://clojuredocs.org or Java Docs as needed -- so I don't have to switch to a browser. I use Portal for all my REPL output -- and keep Calva's nREPL output window hidden (I never type into a REPL).

(midnight here so bed time -- happy to discuss in depth tomorrow or another day)

@U04V70XH6 ok, I will go through and try to make sense

Having to manually tap> is what keeps putting me off

Thanks, I will have a look and bother you in case I can't make it work I guess 😂

Do you mean via https://clojure.org/reference/metadata?

(with-meta {:foo :bar} {:kind :Foo})
=> {:foo :bar}

(meta (with-meta {:foo :bar} {:kind :Foo}))
=> {:kind :Foo}

Or do you mean more along the lines of creating a defrecord and overwriting the default print-methods?

(defrecord Foo [bar]
  Object
  (toString ^String [this] (my-custom-string this)))

(defmethod print-method Foo
  [this ^Writer w]
  (.write w (my-custom-string this)))

(.addMethod pprint/simple-dispatch Foo
  (fn [this] (print-method this *out*)))

Not sure what I mean, as far as what the language actually offers. I just have some things that are kind of like types, and would like for the info that "this is a thing" to present itself on introspection, even though I'm not looking for any sort of type enforcement.

Sounds like you probably want to use https://clojure.org/reference/metadata. Check out e.g. "Applying Viewers" in https://github.clerk.garden/nextjournal/book-of-clerk/commit/70d0459fbe941e689e0c2e7df0afc887eaf5900b/#%F0%9F%A4%B9%F0%9F%8F%BB_applying_viewers to see how Clerk uses metadata notation to pass around and react on type information, without interfering with the original value.

And I just realized, Clojure even has built-in *print-meta* : https://clojure.org/reference/metadata#_print_meta

Thank you. I was already aware of the existence of metadata. The problem (ignoring that it cannot augment simple values ...

(def foo ^:Foo "foo") ;; Syntax error
(def foo ^:Foo 123) ;; Syntax error

> (def foo ^:Foo ["foo"])
nil
> (prn foo)
["foo"]
nil

> (prn (meta foo))
{:Foo true}
nil

Or maybe I just need some trick to get Calva (or nrepl or clojure-lsp) to surface metadata?

Have you tried:

(set! *print-meta* true)

it changes the global state of your runtime, so it would be better to hook into the nrepl printer and just modify it via binding - but this should start printing metadata for all your repl interactions

Interesting idea. I wonder how much noise that will add from other things.

I don't think I realized you could set that globally.

it's a dynamic variable, which is why it uses the asterisk naming convention *_name_* - it's because theoretically, it can be modified at any time; Usually you don't want to modify it globally without scoping it via binding if you can help it :)

You can read more about dynamic vars here: https://clojure.org/reference/vars

But if setting the *print-meta* gives you the desired results, I would encourage you to dig further and see how Calva is printing the repl results, because hopefully you can just hook in and modify that behavior locally with binding vs changing it globally for your entire runtime. Perhaps ask on #CBE668G4R?

Seems like the best answer is probably just to define types. The simplest example would be a record for what would otherwise be map data, since that comes with tagged map-like printing already built in.

(defrecord Foo [foo])
(->Foo "foo")
; => #my-ns.Foo{:foo "foo"}

You need to go through all the files in the folder, and map json/read-value and merge everything later I guess:

(->> 
  (get-filenames)
  (map #(json/read-value (slurp %))
  ...merge)

Untested:

(defn merge-jsons
  "file should be java.io.File, eg (File. string-path)"
  [file]
  (let [all-files (.listFiles file)
        subfolders (filter #(.isDirectory %) all-files)
        subfiles (filter #(.isFile %) all-files)]
    (->> subfiles
         (map #(json/read-value (slurp %)))
         (json/write-value-as-bytes))
    (doseq [f subfolders]
      (merge-jsons f))))

And you have to spit somewhere the result of json/write-value-as-bytes.

(let [{:keys [tag]
       [content] :content}
      {:tag :seriesKey :content ["2372"]}]
  [tag content])

@U04V4KLKC wow, great. Is that syntax for "naming" keys?

I don’t know if there is a name for this because this is the most basic destructuring primitive for maps 🙂 Here is a complete guide for various destructuring options available in clojure. - https://gist.github.com/john2x/e1dca953548bfdfb9844

You can check the official docs here for some examples too! https://clojure.org/guides/destructuring#_associative_destructuring

adding the path of the logback config file as jvm argument, solves the problem java -Dlogback.configurationFile=file:path -jar ...

There is not. See https://ask.clojure.org/index.php/12155/function-returns-sequential-collection-matching-predicate?show=12155#q12155.

https://clojure.atlassian.net/browse/CLJ-2056 there are some idioms you might copy to ypur project but non of them got landed in clojure core yet

cool thanks

Reagent is probably a good place to start. You can use #C034FQN490E to develop instantly. Example website: https://benjamin-asdf.github.io/scittle-prints-itself/

@U02CV2P4J6S thank you. Will check it out. I don’t want to use any frameworks so I’m trying to figure out these things myself.

https://www.youtube.com/watch?v=QEEPXuR5wLk this is a great walkthrough using only vanilla cljs (js interop) irrc

Depending on how text-heavy your pages are – if for example, you're building mostly static HTML with some interactivity tacked on that needs to talk to a backend – then you might want to give HTMX/ctmx some consideration. My understanding is that they offer interactivity without the overhead of JS and react, instead delegating the computation for interactivity to the backend. May not be appropriate if you want to create highly interactive front end content that doesn't require a backend component. https://htmx.org/ https://github.com/whamtet/ctmx

"Nice UI" in this context would be achieved using CSS rather than react; something like TailwindCSS could help you get something nice and customizable quickly. But it's very much a framework, so you may prefer to just use your own CSS instead. https://tailwindcss.com/

Reagent is pretty simple, essentially you write hiccup or selmer & html templates for the content and reagent manages the virtual DOM (updates the page efficiently) I use Bulma CSS library to add some nice styling. You can use a Clojure atom to manage state changes and if the component used data from the state, reagent manages the updates when that data changes. A very simple example: https://practical.li/clojurescript/web-design-basics/clojurebridge-london-website/ This is the development workflow I take https://practical.li/blog/posts/clojurescript-workflow-with-clojure-cli-tools-and-figwheel-main/

Thank you, @U05254DQM I found your website really useful.

@UFTRLDZEW thank you for your advice. I don’t want to use Clojure framework, but I think CSS frameworks should be fine, if they do not introduce too much overheads. I think JS or Clojurescript seems to be “slow” whereas CSS seems to be fast? My personal website is static only, so not sure about the other side. EDIT: can I use garden library with tailwind?

You can change resolver of the formatter to ResolverStyle/LANIENT https://docs.oracle.com/javase/8/docs/api/java/time/format/ResolverStyle.html#LENIENT https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html#withResolverStyle-java.time.format.ResolverStyle- there are a couple of links for you

Sure, let me try that out

thanks @U04V4KLKC

NVM, (xml/parse (.ByteArrayInputStream. (getBytes xmlstr "UTF-8"))) works 😄

Sounds like you want reduce

There are at least some ways that map and apply could be used to apply functions in a sequence to values. For example:

user=> (def fn-lst [inc dec #(+ 3 %)])
#'user/fn-lst
user=> (map (fn [f] (f 2)) fn-lst)
(3 1 5)

And continuing that example for a variation:

user=> (map (fn [f v] (f v)) fn-lst [10 20 30])
(11 19 33)

This is a trivial example while I try to figure this but

(map (fn [x] (x 7)) (repeatedly rand-int))

rand-int needs an arg

Here is something that might be what you are looking for?

user=> (map (fn [x] (x 7)) (take 20 (repeat rand-int)))
(2 5 4 0 6 6 1 4 2 0 6 1 1 2 0 4 1 1 6 4)

Note repeat instead of repeatedly, which do very different things

@U0CMVHBL2 Is it better to "lift" the (take 20 to outside?

I am curious why repeatedly does not work here?

I use repeat all the time but to make seqs of things that are not functions

Takes a function of no args, presumably with side effects, and
returns an infinite (or length n if supplied) lazy sequence of calls
to it

I think it depends what you want -- my only purpose was to make a small example with small output 🙂

So does this

(take 5 (repeatedly #(rand-int 11)))

(That's from clojuredocs)

In that example, rand-int is called with exactly 1 argument, the integer 11

#(rand-int 11) is an anonymous function that takes no arguments.

That's good to know, I did not know you could use anonymous functions like that

Thanks @U0CMVHBL2 and @UC1DTFY1G