timbre

There are logging libraries that include syntactically scoped timers, such as mulog (https://github.com/BrunoBonacci/mulog). While a great library, we preferred timbre (https://github.com/taoensso/timbre) and rolled our own logging timer macro that interoperates with it. More convenient to have such niceties in a Lisp of course. Since we also have OpenTelemetry available, it would also be easy to wrap traces around code form boundaries as well. Thanks OP for the idea!

Mentioning μ/log and no mention of timbre (https://github.com/taoensso/timbre), that is an odd omission. Malli is a great mention, but there ought to be a mention of clojure.spec (https://github.com/clojure/spec.alpha) which has much more mindshare.

If you're not familiar with lisps in general, it might be hard to grok the differences between lisp-macros (as used in Clojure) and "normal" macros you see in other (non-lisp [sans Elixir I think]) languages. But, if you are familiar already, and just wanna see examples of neat macros that makes the API nicer than what a function could provide, here are a few: - https://github.com/clojure/core.async/blob/master/examples/w... - https://github.com/weavejester/compojure - https://github.com/ptaoussanis/timbre - https://github.com/krisajenkins/yesql Furthermore, macros enables APIs like this, that would be impossible to have in JavaScript for example: (spy :info (* 5 4 3 2 1)) => 120 %> 15-Jun-13 19:19:13 localhost INFO [my-app.core] - (* 5 4 3 2 1) => 120 `spy` here doesn't just print what the `` form is returning, but the form

No, I don't think they were hyped at any point. They are used in certain libraries like https://github.com/ptaoussanis/timbre but for things that are simply not possible without macros, for example (timbre/spy (+ 1 1)) will actually print both the expression and the result: DEBUG [ss.experimental.scratch:1] - (+ 1 1) => 2 This is one of my favorite debugging tools. IMO beats a debugger hands down! Printing can also be disabled with a global library flag without code modification. Perhaps if the macros are "simple" they can be unpacked relatively easily. I do understand how mentally challenging that can be for somebody who's just starting with Clojure. I've been using Clojure for a long time and only just recently became more comfortable with macros after I made a conscious effort in that direction. I'm still far from an "expert" in them.

"you can change the fundamental data structure and the algo still works" - it doesn't really pan out, and it's not important in my experience of using Clojure for about ~8 years. What makes Clojure worth it is the pervasive reduction of mutable state across your program without the cost and rigidity of creating types everywhere. Also great sharing of code across Clojure and ClojureScript: - You want your dates to behave the same on client and server? You got it: https://github.com/juxt/tick - You want your logging/debugging code to be the same? You got it: https://github.com/ptaoussanis/timbre - You want good async primitives? No problem: https://github.com/clojure/core.async - And many more... I haven't seen another language that is as good as Clojure(Script) at this. Nowadays .cljc (.clj + .cljs) files really rock.

A few more tricks: - CIDER, the de-facto Clojure environment for Emacs, has a debugger[1]. This is also true for some of the larger IDEs, like Cursive. - Timbre[2] has a number of cool debugging macros, especially spy, which you can tack onto any expression and it'll log it for you. Very useful, similar to the macro in the post, except you don't have to write it :) I really can't overestimate how valuable a real REPL-driven development environment is. [1]: https://github.com/clojure-emacs/cider/blob/master/doc/debug... [2]: https://github.com/ptaoussanis/timbre

I've used clojurescript commercially for a couple of years. It has been a good experience. More than anything it has completely changed my world view (and I'm a very experienced, older programmer who has seen a bit). I feel very lucky to have had this opportunity. IMO, some of the issues you raise are genuine, some not. For example, the JVM startup time issue is never, ever a problem. If it is, you aren't using the tools right. I use Cursive and figwheel etc, so I find the tooling generally fine and in many ways excellent. The trajectory in this area is good. Debugging initially can be rough. Knowing about things like cljs-devtools can dramatically improve things. But, yeah, valid point. And, yes, poor error messages can definitely be a problem initially -- although this has improved over the last year. To get going, I'd recommend you u

Yes, the Java stack traces are probably the worst "ugly" thing in Clojure but from my experience the simplicity of syntax (not to be confused with familiarity, familiar != simple) makes it much easier for someone who's never programmed before to start writing Clojure code vs many other languages where there's a lot of syntax to that you simply need to "know" to get going. Also, on a more advanced note, I've used https://github.com/ptaoussanis/timbre with great success to get nicely formatted and colored Clojure errors and stack traces.