anybody know if there is a #crux channel

nvm it exists already! sweet

does #datomic exist?

@mojitosmi If you click the ➕ next to Channels in the left side bar, it lets you Browse channels

You can also try to just switch to a channel (control-k on Windows, cmd-k on Mac) and just start typing.

(I can't remember whether the "quick switcher" is enabled by default -- check Preferences > Advanced under Search Options)

What's the recommended approach for dealing with dates and times in clojure? It seems like a bit of a mess. Should I stick with Java 8 APIs?

Either use Java Time directly or a wrapper like cljc.java-time or tick

Is it possible to mix Java and Clojure to implement some complex projects？ I mean here is a Clojure open-source project, I need to reconstruct it, So which is the better way? Reconstruct completely by Java or by mix Java and Clojure?

@xu20151211 You can have a Java app that loads and calls into Clojure code, and you can have a Clojure app that calls into Java code.

See https://clojure.org/reference/java_interop for some examples/background.

When we first adopted Clojure at work (a decade ago now), we used it for low-level stuff and gradually replaced parts of our legacy applications -- so we had mixed language projects, calling into Clojure. Over time we rewrote more and more of them in Clojure.

Hello, is it possible to do something like this for spec?

(s/def ::plain-coord
  (s/keys :req-un [::row ::col]
          :opt-un [::sheet]))

(s/def ::merged-coord
  (s/and
    (s/keys :req-un [::first-row ::first-col ::last-row ::last-col]
      :opt-un [::sheet])
    #(<= (:first-row %) (:last-row %))
    #(<= (:first-col %) (:last-col %))))

(s/def ::coord
  (s/or :merged (s/keys :req [::merged-coord])
    :plain (s/keys :req [::plain-coord])))

(s/def ::coord
  (s/or :merged-coord merged-coord?
    :plain-coord plain-coord?))

Like what I really want is to be able to do something like

(s/def ::coord
  (s/or ::merged-coord 
    ::plain-coord))

there is both s/merge and s/or

it's unclear to me what you want or what doesn't work

one handy (undocumented) tool for use with s/or is s/nonconforming

Hmmm, I would like for :coord to either take the the form of ::plain-coord or ::merged-coord

in what way does it not work?

(s/def ::coord
  (s/or :merged ::merged-coord 
    :plain ::plain-coord))

Let me try that

Thanks, think that should be working! Not sure why I didn't try that just now

if you're conforming, s/or will conform with the :merged or :plain tag which you likely don't want - in that case, wrap the spec in s/nonconforming. if you're just using s/valid? then it doesn't matter

just using s/valid? but for subsequent reference, by wrapping you mean ...

(s/def ::coord
  (s/or (s/nonconforming ::merged-coord) 
    (s/nonconforming ::plain-coord)))

@zackteo (s/nonconforming (s/or ...)) as I recall...

It turns the whole s/or part into a non-conforming spec, i.e., if it matches, it returns the original data structure.

yeah, wrap the nonconforming around the s/or

it conforms with the spec but returns the original value

user=> (require '[clojure.spec.alpha :as s])
nil
user=> (s/conform (s/or :int int? :str string?) 42)
[:int 42]
user=> (s/conform (s/or :int int? :str string?) "one")
[:str "one"]
user=> (s/conform (s/nonconforming (s/or :int int? :str string?)) 42)
42
user=> (s/conform (s/nonconforming (s/or :int int? :str string?)) "one")
"one"

we will probably have some kind of nonconforming or option in spec 2

I guess it also prevents similar conformance on any nested specs? (In the arms of the s/or) Right, @alexmiller?

doesn't prevent, just ignores

it just conforms, then returns the original value

So you'd get a different result to flowing it through (s/conformer second) (which would still preserve nested conformance and just erase the tag of s/or)

correct

Just something to be aware if you actually need some conformed values deeper in the data (which I've needed occasionally).

good morning 😪

Hello, I was wondering about the difference between "first" and "peek". Would their results ever be different? Is there maybe a performance difference in some cases?

Hi! Would that be a good solution to replicating items in a sequence?

(fn [xs count] (mapcat #(take count (repeat %)) xs))

I don't know if it is better, but you could use #(repeat count %) in place of #(take count (repeat %)) there to get the same results. Unless one is worried about optimizing run-time performance to the utmost, what you have and that small variation both seem like perfectly good ways to me.

Ah, nice, I thought repeat is a single arg function. That makes it easier to read for sure, thanks!

repeat has 1-arg and 2-arg variants

Awesome. Thanks!

hmm, why do I get a server error when trying to read a css file

(defn create-image-element [{:keys [object-number width height url]}]
  [:html
    [:head
     [:meta {:charset "utf-8"}]
     [:title " Most popular paintings from the Rijksmuseum "]
     [:link {:href "public/css/styles.css", :rel "stylesheet"}]]
    [:body]])

from the root , there is a styles.css in that directory

A guess would be to remove the “public/” part. To test it you’d want to try and access the css file directly in the browser.

Typically a static file server points into a directory (often called “public”), while your root directory contains all the source code.

sorry, tried it without any luck

do you have a project.clj file or a deps.edn file?

yep, that looks like this :

(defproject paintings "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url ""
  :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0"
            :url ""}
  :dependencies [[org.clojure/clojure "1.10.0"]
                 [cheshire "5.9.0"]
                 [clj-http "3.10.3"]
                 [ring "1.8.2"]
                 [compojure "1.6.2"]]
  :repl-options {:init-ns paintings.core})

You said you have a public/css directory, is that in the project root, or is it in resources/public/css?

just public/css` in the root directory

It’s conventional to have resources/public/css, and you may be libraries that are expecting that.

You might want to have a look at the “Static Files” section at https://learnxinyminutes.com/docs/compojure/

(I had to google that--I’ve switched from using compojure to using reitit, and I didn’t trust my memory of how compojure works.)

Maybe I need to change something then at my routes

(defroutes app
  (GET "/" [] (-> (display-data)
                  (convert-to-hiccup)
                  (hiccup/html)))
  (GET "/favicon.ico" [] ""))

is public on your classpath?

yes, it working

I had to make the directory resources

and add this to my routes (route/resources "/")

:thumbsup:

Hi Guys, I have no experience with a clojure, I have to add a new line into the clojure logic, I have a list of strings: "a", "b", "c" etc... I need to return true/false if the following list contains a string equal to the op-name variable. If the list cantains the op-name I need to return true, otherwise false. Could you help me with a quick snippet for this. Will appreciate that.

BTW. I will have to create this list first.

(some (set [op-name]) list-of-strings)

lemme check if that works though 😅

some could be a useful function for you. "Returns the first logical true value of (pred x) for any x in coll," So (some (fn [x] (= x op-name)) my-list) would return whether that list had a member equal to op-name

Thank you guys, does the list of string should be a comma separated like (some (set [op-name]) "a","b","c") ?

commas are literally whitespace in clojure. ["a" "b" "c"]

Also available options: (list "a" "b" "c"), '("a" "b" "c") , (vector "a" "b" "c") All arguably less pretty

Nice! Thank you for a quick help! Have a good day/afternoon 🙂

pure vs. referential transparency. Is it the same thing? This article is confusing: https://edward-huang.com/functional-programming/tech/programming/scala/2020/01/30/pure-function-vs-referential-transparency/

Hi folks - I’m a bit of a beginner, and I’m working on a project that takes a CSV file (through Java interop), does some processing on it, and exports the new file to [filename]-processed.csv. I’m using https://github.com/clojure/data.csv/ and it works splendidly!

(with-open [reader (io/reader file-info) writer (io/writer new-file)]
      (as-> (csv/read-csv reader) $
            (map #(eval-line % header-info) $)
            (csv/write-csv writer $)))) ; ALL THIS WORKS! 

use reduce (over a possibly partitioned set of data) instead of just passing all the data to write-csv

(and don't use as-> when ->> will do)

@hiredman Thanks about the as-> comment. I think I needed it at one point, now I don’t.

Hi! Is there any nice standard function for the use-case of "if expr is true, return expr otherwise return other"

(if expression
    expression
   (other-expression))

or

thanks 🙂

to easy

In a video Hickey alludes place oriented programming (even if it's update-in-place) is bad, what problems does PLOP cause?

for one thing, it means you need to understand every function that has access to that place in order to understand the code

but as I recall he went into quite a bit of detail in that same talk

I think the main problem is "fragility"

@kaxaw75836 as a counterexample: when debugging clojure code, I can usually "capture" a value as it appears in a function, and then debug my code based on that value in isolation. In a C++ program that rarely if ever helps, and I need a stepping debugger to understand what happens to the places the function sees.

in good clojure code, what matters is the value, the place isn't my concern

This is one of my favorite clojure advantage. Even if I know this is not an exclusivity

right, even in java you can snapshot some object out of a function to play with it in test code (in c++ this probably leads to a memory leak, or accessing freed data - place problems)

@noisesmith are you referring to immutability? or abstracting the machine?, if so is no different in JS or Python?

@kaxaw75836 I'm referring to the difference between thinking about places as the building blocks of code, vs. thinking of values as the building blocks

it's different than JS or Python because most JS and Python code still works in terms of updating hidden internal state, but those are still less place-bound than c++

@kaxaw75836 but this is a very general thing - it even applies to the difference between managing the contents of a tree of files (places) vs. data in a db (values with other values that describe their relations)

IMHO PLOP has two aspects that are worth considering. Like @noisesmith said, it decreases your facility for reasoning. Another aspect is increasing brittleness: code and data that change over time propagate changes to rigid structures around them.

talking about DBs, he mentions tables in RDBMS is also a place(bad) that creates coupling, and that documents are also a place that create coupling

@denis.baudinot right, in imperative place oriented code 90% of your code is ad-hoc inline adapters between ad-hoc data structures, this kind of thing doesn't even need to exist in clojure

@kaxaw75836 all programs have places, perhaps I picked a bad example, but this isn't a black/white thing, it's a way of guiding a design

The point is that you could use java with only immutable object and the place orientation of java is less an issue.

Clojure is not the only community that concerns itself with disentangling from PLOP. Game programmers have introduced Struct of Arrays, Data Oriented Design and Entity Component systems. They use data structures that are more relational and adaptive, mostly for performance reasons (CPU caching) but this has also a decoupling effect and generalises functionality. Frontend developers are shifting towards using frameworks like React etc., which have a clearer separation of state, data flow and rendering. The problems around PLOP seems to be unspecific to this community.

1977 wow, the summary looks pretty good high level overview will have a read

he also is critical of lambda calculus based programming languages, because he wants a more restricted basis to make things easier to reason about

the system he describes sort of sounds like coding directly in a combinatory logic like SKI, but less bare bones, which seems kind of like a nightmare

so he also do not like Haskell which I like a lot 😢

hi what's your favorite way to do websockets or ajax in clojureland?

here's a question i've been wondering about for some time. in the java community (and others) folks will often favor so called "clean code". that can mean all sorts of things, so i'l be more specific. stuff like "one level of abstraction per function". decomposing functions into tiny helpers with "descriptive" names that hide the mechanical details of what you're doing. adding in domain concepts, in the form of function or object names, that hide the mechanical details of what you're doing. i'm in a clojure shop right now, having come from a java shop, and i'm finding that there is a high high tolerance for long functions with many levels of abstraction and few, if any, named helpers to express what you might call intent. just big expressions. stuff that would never have made it past code review at my last place. what do folks think? is there a deliberate preference for more inline, nested, low level expressions over extracted helpers with names? or is it just a tolerance thing? i'm very curious

there's a Martin Odersky talk (that i can't find right now) that expresses this well. he says, well, in scala, we have all these great abstractions and general purpose data manipulation functions (a la clojure). and so you could write a dense, multi-step transformation. but, according to Odersky, that would be a mistake because it would be too impenetrable for future maintainers.

@michael740 I would say that Clojure in general encourages small, pure functions, with good names, that isolation mutable state to the edges of the system -- but not all Clojure programmers produce such code, just like not all Java developers write "clean code".

There is no right and wrong here. http://number-none.com/blow/blog/programming/2014/09/26/carmack-on-inlined-code.html

Clojure advocates dsl which I find very close to language metaphor used in clean code

I think there is no point in putting things into defs that don’t need to be referenced. We have reader macros and a repl to evaluate/ignore things at the expression level

Structure is essential, but wether that structure is composed of function declarations is almost orthogonal to this

The "clean code" concept comes out of the culture of enterprise consultants. The clojure community is smaller, so it attracts fewer of those.

There is also something to be said of the mental overhead of naming things.

having said that, i usually write small functions, it comes naturally. But some functions are just large lists of doing things in sequence, explicitly, that are the kind of functions where keeping them large makes sense.

@denis.baudinot, as told in clean code, I find helpful to tell the intentions. Small functions help to do so

there are also many critiques of the different formulations of "clean code"

@denis.baudinot, even in the case you mention, I find helpful to explode in small local function, it helps readibility and testability . Maybe im too young in the language ...

it’s orthogonal to clojure wether a function/procedure should be large or not

you can visually structure a large function to make it nicer to read

again, I don’t really write a lot of large functions anyways. I’m rather against the notion that there should be some kind of limitation to this

if you haven't read elements of clojure yet (I am behind the times and haven't finished it yet), I don't think it mentions "clean code" by name, but it functions to some degree as a critique of "clean code" and similar stuff

Ok here is a more specific follow up question: To build up application state, aka ‘load’ we usually do a whole bunch of plumbing in sequence, connect to a db, read some files, load in configuration… Should this be a large, single procedure, where the effects are explicit, in your face and the sequence of steps is clear? Or should this be composed of a abstracted, possibly data-driven configuration system? I think the first one is easier to understand and more “honest”, while the second opens up opportunities to build stuff that is about that process, which has operational benefits.

I want to read the attributes of a file and for that I am using https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#readAttributes-java.nio.file.Path-java.lang.Class-java.nio.file.LinkOption...- like this (Files/readAttributes (io/file "file-path") BasicFileAttributes []) but I am getting an exception error: java.lang.IllegalArgumentException: No matching method readAttributes found taking 3 args how can I represent java varargs in Clojure?

https://clojure.org/guides/faq#varargs

in this case you might want to use something like: (Files/readAttributes (.toPath (io/file "file-path")) (into-array LinkOption [LinkOption/NOFOLLOW_LINKS]))

note that io/file returns a http://java.io.File but that method takes a Path

sweet! Thank you very much!

Hello

One question. How can I define a fixed set of values to a map attribute. Like an enum in java

#{}

Just as concise a clojure. It rocks

in general, you usually don't need analogs to Java enums at all

either just use the constant values, or use :keywords for options (instead of public static final String blah). if you really need to collect them (for use of the full set somewhere), put them in a set or sometimes a map if there is ancillary info

or I guess a vector if there is some necessary ordering

you may be tempted to (def my-option :my-option) - resist the urge, just use :my-option

Is there a function in Clojure to check if a number is in a closed-open range? E.g. a <= x < b ? I know I can use the expression (<= a x b), but that's a closed-closed range. I also know that I can use an and to achieve what I want, but I would prefer something more succinct or more math-aligned. Any suggestions? Thanks

I'm considering defining a function <=< that does that, but I'm guessing there should be something like this already done in core?

not that i'm aware