Java logging is a gigantic can of worms @stopachka We've gone back and forth on several solutions and we eventually ended up using org.clojure/tools.logging with log4j2 as the implementation and deps for that and the various bridges to route all logging through it. tools.logging can be told to use any of several logging backends so that should probably be your "first stop" on logging. Nearly all of the community logging libraries have a variety of gotchas that ultimately make the logging problem worse, IMO.

This is good reading on logging https://lambdaisland.com/blog/2020-06-12-logging-in-clojure-making-sense-of-the-mess

Using slf4j/logback per that blog post is likely to be fine for your needs. I really don't like that slf4j treats FATAL as ERROR and I don't want any XML configuration files so that's why we prefer log4j2 (we can use .properties files, it does auto-loading of changed log files without dropping log items, it supports MDC -- not sure whether slf4j/logback does?)

But, yeah, to your basic question, using a JVM option to select the appropriate logging context is reasonable. We default to the production log config but override it per-dev with an environment variable or a local JVM option (we run SQL migrations locally with a different log config to when we're running tests, for example).

is there any clean way to inspect the values in a channel before taking from it? or is this getting away from the purpose

i’d like to see if it either has a certain number of bytes, or whether it contains a delimiter

you could implement a custom buffer that offers this, but it also means that using that information in program logic invalidates promises that CSP makes

eg. (if (> (messages-count c) 4) ...) - that's a race condition, there's no way to know if the count is for inside the ... code or not

all you know is that for a moment that was true

if you have a single consumer of the channel in your design, you could use a closed over collection of inputs in a go-loop and hold off execution until the collected data meets some condition

just to make sure i’m understanding, something like

(go-loop [acc []]
   (conj acc (<!! chan))
   (when stuff
      (handle acc))
   (recur))

seems like it would work.

the acc needs to be an arg to occur, conj doesn't have side effects

but yes

right, yeah

(go-loop [acc []]
  (let [acc' (conj acc (<! chan))]
    (if (some-condition? acc')
       (do (handle acc')
            (recur []))
       (recur acc'))))

also note that using <!! inside a go or go-loop block can stall all of core.async, use <! inside go

brilliant, thank you

Hello all just getting started with Clojurians.

Hi! I'm running into a strange behaviour and I have no clue what could be happening... I have the following reagent component:

(defn FullCalendar [ date-vec
                    events
                    view move-resize-cb
                    dbl-click-cb
                    selection-cb
                    event-select-cb
                    navigation-cb
                    toolbar-component
                    sel-event
                    ]
  (prn "sel-event 1" sel-event date-vec)
  (let [localizer (. BigCalendar momentLocalizer m)]
    (fn [date-vec events view sel-event]
      (prn "sel-event 2" sel-event date-vec view)
      [:div
       [:> DndCalendar {:localizer localizer
                        :date (convert-date date-vec)
                        :events events
                        :views ["day" "week" "month" "agenda"]
                        :view (if (or (nil? view) (empty? view)) "month" view)
                        :titleAccessor #(:int-title (js->clj % :keywordize-keys true))
                        :resizeable true
                        :toolbar true
                        :step 30
                        :timeslots 2
                        :selected sel-event
                        :components {:toolbar (if (nil? toolbar-component)
                                                (reagent/reactify-component Cal-Toolbar)
                                                (reagent/reactify-component toolbar-component))}
                        :scrollToTime cal-start-time
                        :eventPropGetter
                        (fn [event]
                          (if (equal-events? event sel-event)
                            (do
                              (prn "events are equal so selected" event sel-event)
                              "rbc-event rbc-selected")
                            (do
                              (prn "different events" event sel-event)
                              (set-background sel-event))
                            ))
                        :onNavigate navigation-cb

sel-eventis coming from a re-frame subscription in the call to this component. The thing that I don't understand is that in the first prn I can see the correct value of sel-event (a map with different fields), but when I pass it into the fn the second prnand the rest of the calls treat it as a #object[Function]

Why can that be? Why is this map treated as a function inside of the render fn ? Thanks!

Good Morning Clojurians. I am trying to convert the https://github.com/seancorfield/usermanager-example to work with Postgres, but I am getting an error:

HTTP ERROR 500 org.postgresql.util.PSQLException: ERROR: operator does not exist: integer = character varying Hint: No operator matches the given name and argument types. You might need to add explicit type casts. Position: 28

(ns bubbleuptop.model.user-manager
            [next.jdbc.sql :as sql])

(defn delete-user-by-id
  "Given a user ID, delete that user."
  [db id]
  (sql/delete! (db) :users {:id id}))

hey everyone, how can i get the byte form of ÿ ? (extended ascii)

unchecked-byte throws character cannot be cast to number

Is the error message you see: "Value out of range for byte: ÿ"

The numeric range for a JVM byte is -128 to +127. That Unicode code point for that character is not in that range. Try int

oh yeah! that did it

Or unchecked-int if you prefer

255

thanks!

more generally, given an encoding, you can get the sequence of 8 bit signed values that would be interpreted as that value in that encoding - characters don't have bytes, but encodings do map characters to sequences of bytes

user=> (->> ["US-ASCII" "UTF-8" "UTF-16" "UTF-32" "Big5" "IBM-Thai"]
     (into {} (map (fn [encoding]
                     (let [decoded (.getBytes "ÿ" encoding)]
                       [encoding
                        {:bytes (seq decoded)
                         :reconstructed (String. decoded encoding)}]))))
     (pprint))
{"US-ASCII" {:bytes (63), :reconstructed "?"},
 "UTF-8" {:bytes (-61 -65), :reconstructed "ÿ"},
 "UTF-16" {:bytes (-2 -1 0 -1), :reconstructed "ÿ"},
 "UTF-32" {:bytes (0 0 0 -1), :reconstructed "ÿ"},
 "Big5" {:bytes (63), :reconstructed "?"},
 "IBM-Thai" {:bytes (63), :reconstructed ""}}
nil

the supported encodings are https://docs.oracle.com/en/java/javase/14/intl/supported-encodings.html#GUID-187BA718-195F-4C39-B0D5-F3FDF02C7205

@gtzogana - note that ÿ is not "extended ascii", and AFAIK there is no such encoding - according to unicode "ÿ" is a code point, and an encoding decides which bytes (and how many, and in what order) correspond to that code point

@gtzogana and I was partially wrong above - 255 (int) is the same as (-61 -65) according to the jvm, but this depends on things like the jvm's default encoding, and byte order, which are implementation details that are bad to rely on

(unless your question is very specifically and only about one version of java, because it's allowed to change those things AFAIK)

Hello, So I created a coljure-script project based on a reframe template and added calva and re-frame-10x. I used this command: lein new re-frame py_project +calva +10x To run and test my project I use the "jack in" REPL in calva and it works great. However I noticed that +10x reframe tracing slows down a bit my execution. Is there a way to elegantly remove/deactivate 10x from the lein project? What I would do otherwise is create a new lien template without +10x and copy paste all my .cljs files. Thank you for your help

Clojure sages how do i schedule functions to run at certain times. Library recommendations or roll my own?

What's the practical differences between creating a var using def say of a map and having the same map but it being a function using defn with no input parameters?

With def it will be evaluated at load/compile time. With defn it will be "evaluated" at call time (although it will still be compiled at load time). So any differences will depend on what is in the hash map.

As an example from Clojure From the Ground Up:

(defn atlas-v
 []
  {:dry-mass  50050
   :fuel-mass 284450
   :time 0
   :isp 3050
   :max-fuel-rate (/ 284450 253)
   :max-thrust 4.152e6})

The other difference is for REPL workflows: references to a def will be compiled in with the initial value, so if you change the def in the REPL, references to it will still refer to the old value. If you use a defn, each call will always produce the latest value of the function.

(you can get around that by using #'atlas-v instead of plain atlas-v and then you can change the def and its new value will be picked up)

For a hash map like that which is all constants, I'd use def.

Ok, cool. Thanks for the clarifications. I'm a little stoked I was thinking the same with it just being constants which is why I asked. Figured I was missing some kind of functionality

Perhaps it's a nod to the future where the Atlas V data might come from somewhere else (but then I would expect it to have some sort of argument that could be queried to find where to get the data).

0-arity functions are nearly always impure, unless they are deliberately recomputing something on every call (such as a lazy sequence so you can consume it without holding onto the head).

Hey, is there a way to inspect anonymous function?

e.g. find out what a function like this #function[namespace/eval14220/fn--14227] does.

I want to learn how to read the output of spec/explain-data. I'm sure this is full of useful information but I couldn't make heads or tails of it... it's from looking at cider inspect last result

Class: clojure.lang.PersistentArrayMap
Contents: 
  :clojure.spec.alpha/problems = ( { :path [], :pred clojure.core/map?, :val [ :com.logicgate.helpER.source/indent 4 ], :via [ :com.logicgate.helpER.specs/scenarios :com.logicgate.helpER.specs/scenario :com.logicgate.helpER.specs/specification ], :in [ 0 0 ] } { :path [], :pred clojure.core/map?, :val [ :com.logicgate.helpER.source/tag "describe" ], :via [ :com.logicgate.helpER.specs/scenarios :com.logicgate.helpER.specs/scenario :com.logicgate.helpER.specs/specification ], :in [ 0 1 ] } { :path [], :pred clojure.core/map?, :val [ :com.logicgate.helpER.source/message "Adding a user in an SSO environment" ], :via [ :com.logicgate.helpER.specs/scenarios :com.logicgate.helpER.specs/scenario :com.logicgate.helpER.specs/specification ], :in [ 0 2 ] } { :path [], :pred clojure.core/map?, :val [ :com.logicgate.helpER.source/level 0 ], :via [ :com.logicgate.helpER.specs/scenarios :com.logicgate.helpER.specs/scenario :com.logicgate.helpER.specs/specification ], :in [ 0 3 ] } { :path [], :pred clojure.core/map?, :val [ :com.logicgate.helpER.source/indent 6 ], :via [ :com.logicgate.helpER.specs/scenarios :com.logicgate.helpER.specs/scenario :com.logicgate.helpER.specs/specification ], :in [ 1 0 ] } ... )
  :clojure.spec.alpha/spec = :com.logicgate.helpER.specs/scenarios
  :clojure.spec.alpha/value = ( { :com.logicgate.helpER.source/indent 4, :com.logicgate.helpER.source/tag "describe", :com.logicgate.helpER.source/message "Adding a user in an SSO environment", :com.logicgate.helpER.source/level 0 } { :com.logicgate.helpER.source/indent 6, :com.logicgate.helpER.source/tag "describe", :com.logicgate.helpER.source/message "Navigate to Admin -> Users", :com.logicgate.helpER.source/level 1 } { :com.logicgate.helpER.source/indent 8, :com.logicgate.helpER.source/tag "describe", :com.logicgate.helpER.source/message "Click on \"+ New User\" button", :com.logicgate.helpER.source/level 2 } { :com.logicgate.helpER.source/indent 10, :com.logicgate.helpER.source/tag "describe", :com.logicgate.helpER.source/message "the \"Send Welcome Email\" checkbox input", :com.logicgate.helpER.source/level 3 } { :com.logicgate.helpER.source/indent 12, :com.logicgate.helpER.source/tag "it", :com.logicgate.helpER.source/message "is displayed", :com.logicgate.helpER.source/level 4 } ... )

Anybody willing to help a Clojurian newbie here? I am trying to implement some typical coding questions to get up to speed. I'm struggling a bit with the typical of computing the depth map of a binary tree 4 / \ 7 9 / \ \ 10 2 6 \ 6 \ 2 Implementing this in TypeScript was really trivial, but it relies on the global map being passed and modified around:

I wanted to try to implement it in Clojure trying to stay immutable as much as possible, but I am struggling. Anybody has any advice?

The depth, meaning the maximum number of steps from the root to any of the leaves?

So 4 in your example tree of your figure?

@andy.fingerhut Thanks for chiming in! Not exactly. The idea is to group all the items by the depth in the tree

So the output would be something like this:

On level 0 we have 4, on level 1 we have 7 and 9… and so on

I guess this is not really a Clojure specific question, it's more about how to implement this without using mutable data structures

So you want to return a map whose keys are the depths of all nodes, and the value corresponding with each key is a list of nodes with that depth?

Correct!

the general concept is to use an accumulator holding things that get updated, and pass it to a recursive call or reduce step

@noisesmith So…reduce all the way down?

I'll have a one liner in a moment

So one approach is to somehow return a list of maps where each has the depth of a node, and the node, e.g. {:depth 1 :node <whatever you want to use to represent a node>}. Then call (group-by :depth foo), where foo is that list of maps.

For the 'somehow' step that comes first, you can use a recursive function that take a parameter current-depth, and returns {:depth current-depth, :node current-node}, and append that to the list returned by a recursive call on all children.

how do folks configure library behavior? for example, I'm writing a tiny logging library to teach myself clojure and I'd like the user to be able to configure certain behavior once, e.g. set a boolean to true or false I found dynamic variables (`def ^:dynamic foo ...`) but wanted to avoid having the user wrap every call in a binding

you only need binding if you want different values in different contexts, you can use set! on the root value