I think part of the reason is that it is idiomatic for experienced Clojure developers -- you should understand this when you see it, because it is used frequently.

Another reason is a little bit of efficiency. The definition of empty? is basically (not (seq Coll)) , so using not around empty? is sometimes double-negating the return value of seq

In terms of the part of the definition of the word "concise" that means "brief", (when (seq s)) is of course also shorter.

I do not understand what you mean by "overhead of moving a map/vector to a sequence", but happy to address that concern if you can explain what you mean.

For example, if you are thinking that calling seq on a vector immediately does an O(n) time traversal of all n elements of the vector, that is not the case. seq returns in O(1) time, creating and returning an object that you can call first and rest on it, each of which returns a value in O(1) time (well, being nit-picky they are not always O(1), but the ones that aren't are typically something like O(log n) where the base of the logarithm is 32)

Using seq and rest to traverse all elements of a vector/map/set will take O(n) time and allocate O(n) new objects. That is the nature of things when dealing with immutable values. Clojure reduce can avoid that O(n) memory allocation for built-in collections, and for custom collections that implement the necessary support for it to avoid the O(n) memory allocation.

Thanks! also for the o(n), didn't know that :)

are you ok with not using spit?

(with-open [fos (FileOutputStream. "bytes.out")]
  (.write fos (into-array Byte/TYPE (.getBytes "bob"))))

thanks 😉

There are some nice facilities in as well.

(require '[ :as io])

(with-open [os (io/output-stream "bytes.out")]
  (io/copy (into-array Byte/TYPE (.getBytes "bob")) os))

Or even:

(io/copy (into-array Byte/TYPE (.getBytes "bob")) (io/file "bytes.out"))

> calva lein repl often doesn't give any stacktrace Can you describe a scenario when this happens?

I'll post it here the next time it happens 🙂 Typically a nil value that shouldn't be there, e.g. it should have been a function, but I messed up, now clojure tries to call (nil & args), throws a NPE, but without stack trace, only 2-3 lines that point to read evaluation of the REPL, nothing about the location of where it happens inside my code.

As a clojure beginner, rather challenging to debug 🙂

I think you run into a limitation of Calva there. Run the same code in the Calva REPL window and it should produce a stack trace for you. (You'll need to expand it, using the All, Clojure, etc links).

I run it in the calva repl window inside vs code, or is that not what you mean?

(thanks for the help btw! you're the creator of Calva right? In that case, just wanted to say that calva + vs code really made clojure a lot more approachable! So thanks for that!)

You're welcome!

I usually do not evaluate things in the REPL window, but when I am curious about a stack trace I do. So what does it look like when you do not get a stack trace? Can you paste a screenshot here?

Sometimes I get this, sometimes it's without the interruptible_eval part, just 1-2 lines pointing to read-eval-print. This is in my repl window in vs code

In this case, the NPE comes from calling nil as a function.

JVM has a parameter. @frederikdieleman Are you using Lein?

That looks like it is a bit outside what Calva can influence, unfortunately.

I am @UJRDALZA5, should I use some parameters in my project.clj file?

@U0ETXRFEW no problem, writing specs will hopefully minimize the amount of times this creates frustrations 🙂

Using the option -XX:-OmitStackTraceInFastThrow is often a good idea (maybe always?) when starting a JVM, and I believe is not the default behavior.

I do not know if that will make a difference in your case, but good general advice for using Clojure/Java.

Yeah, I was thinking about this option. But I read somewhere it is on by default in Lein.

One could use a command like ps in macOS or Linux to see all command line options to the java command after starting lein to confirm or refute that.

I just started lein repl outside of any Lein project directory, and it started a REPL with a java command line that does not use that option.

When I created a brand new lein project directory, changed into it, then ran lein repl , it did use that command line option.

I don't know the rule for how lein operates here. If I wanted it to be in there reliably, I would personally add it to my project.clj file.

I also read that lein uses it as a default, but I'll double check 🙂

if your nested thing gets too big it might be worth investigating a database like Datahike, Datascript, Datomic etc that will free your data from being coupled to a particular tree, with one graph you can create as many context dependent trees as you like using datalog and pull

then when you have that ability you can make changes to one tree without affecting the others, at the moment I imagine your app is all coupled together because everywhere expects one shared structure (or one shared tree to put it another way)