what's an idiomatic way to thread a nilable value through multiple functions? should i use multi-arities thoughout or?... (def f1 ([] (f1 nil)) ([x] (if (nil? x) (f2) (f2 x)))) (def f2 ([] (f2 nil)) ([x] (...)))

alternatively, i guess i could pass it through and only interrogate it at the terminal

like this

(def f1 [x] (f2 x))
(def f2 [x]
  (if (nil? x) ... ...))

A lot of functions will naturally compose to return nil when given nil

But if yours doesn't, ya, whatever way you want.

But if you're concerned about threading, and not really about designing a fn that returns nil on nil. You could look into using some-> and some->> instead

i've never heard of those, thank you for the heads up

Im working on an application that has degraded to a mess. It uses Apache POI as one of its main dependencies. (Basically acts as a wrapper for it) The users uploads an excel workbook and then use the web app to input values, the application evaluates the spreadsheet and returns the outputs. I am using VisualVM to try and pinpoint where exactly the bottleneck is and to my surprise none of the functions that I suspected are showing up. This could be because I dont know how to use VisualVM. Here is a screenshot of the result

the two clojure.lang.reflector methods nearest the top should be combined - because the same fix eliminates both, and when combined they are near the top (under what is essentially polling that shows up looking like work)

waiting on a promise-deref / poll / select are all basiically polling, so shouldn't be optimized

*warn-on-reflection* will usually help you eliminate the reflection overhead

user=> (doc *warn-on-reflection*)
-------------------------
clojure.core/*warn-on-reflection*
  When set to true, the compiler will emit warnings when reflection is
  needed to resolve Java method calls or field accesses.

  Defaults to false.
nil

I got a wall of orange text! Let me fix those reflection warnings. Good catch, perhaps this is the golden ticket

I've gotten into the habit of putting (set! *warn-on-reflection* true) immediately after my ns form in almost every new file these days 🙂

Maybe I should put them in the clj-new templates? 🙂

I learned the other day that there's a clj / deps.edn version of lein check, I wonder if that turns on reflection warnings

oh yeah, it does https://github.com/athos/clj-check

@mario.cordova.862 after coming back and looking again, it looks like a significant amount of time is spent on file system ops - I don't know your domain, but maybe active objects don't need to be files on disk? A common mistake is thinking that since the thing you work on is commonly refered to as a "file", that it needs to exist on a file system while your app works on it

but then again it could be that POI is inflexible and can't use in-memory data (?)

eg. once I worked on a webservice that resized files for dynamic frontends, and we eliminated most of our turnover latency by doing all the image ops in memory and not using the disk except for caching

That could be the case but I am not familiar enough with the codebase to know enough about what exactly is going on. As far as I am aware the WorkBook object should be in memory.

I know we are doing something wrong because our operations are taking 2-3 mins

hey team! is there any preferred directory structure for clojure?

example:

src
|-> user
    |-> repository.clj
    |-> controller.clj 

@tjb Do you mean beyond the resources/`src`/`test` top-level part?

correct!

Not really. Different people -- and different companies -- prefer different things.

ok cool!

ima role with the one i posted above

I tend to separate things by "domain" concepts more than "function", although within a pure sort of MVC web app, the core is often broken into handlers, model, views or some such.

where would the controller live in that case?

under model?

controller = handler

gotcha!

I'd use controllers in other languages but Ring talks about handlers so...

and model would be DB calls then i assume

is there such thing as a service layer?

I've never been a fan of a generic "service" layer. I think that is a bit artificial.

would you throw those types of methods in the handler?

I think you'll see some sort of "store" section in a lot of Clojure apps but I think, overall, things are a lot more organic.

I tend to start with one function per "request" (or "route") and group "related" functions together in a single handler... so maybe ws.admin.handlers.photos would be all the photo-handling functions.

And each of those would start off doing all of whatever is needed and then I organically refactor into smaller functions as needed and shuffle those off into different parts of the domain and/or "store" or whatever.

ahhhhhh

thats a v cool method

At work, we tend to evolve our structures quite a bit over time.

We have a monorepo now, with about thirty subprojects. Some of those are sort of "core" function for different parts of our overall system, some of them are actual "web apps".

Some of our apps don't have the handlers/model/views separation, some do. Kind of depends on what the app looks like -- whether it has a small number of generic views or a larger number of specific, more complex views. Same with the handlers and "model" aspects.

Here's a concrete example of one app that doesn't have that breakdown:

ws
└── seo
    ├── geo
    │   ├── affiliate.clj
    │   ├── core.clj
    │   ├── data.clj
    │   ├── listing.clj
    │   ├── locale.clj
    │   ├── page.clj
    │   ├── photo.clj
    │   ├── profile.clj
    │   └── search.clj
    ├── geo.clj
    └── sitemap.clj

very interesting! i like that there is no strict way that a project must be structured

And then here's another app that is much more traditional MVC-structured:

$ ls ws/admin*
ws/admin.clj

ws/admin:
handlers  model  screening.clj  views  web

Main entry points are ws.seo.geo above and then ws.admin below.

ooo

actually i like that structure

i may mimic it!

The admin app has 30 handler namespaces and 16 model namespaces.

The SEO Geo app is the total code shown.

model though is not in the sense of a java model correct?

"domain model"?

correct

It has namespaces corresponding to separate aspects of the domain model, yeah, but not "objects"/"classes".

the handlers correspond instead to the sections of the web app itself, not the domain.

gothca

thank you for another clojure lesson @seancorfield!

Feel free to hit me up in DMs any time you have Qs.

(I can share more of how we do stuff in private)

thanks a ton sean!!

i may in the future 🙂

what's the resources dir typically used for?

Non-code stuff -- CSS JS images

EDN files

Hello i've gotten very used to luminus and how it operates BUT i have no idea how to setup 'batteries' and create my template. I started with lein new app X and i'd like to grow it to have 'batteries' similar to luminus (clj, cljs, db, api, reloaded workflow....) are there any resources/tutorials or something i could have a look at this that would get me started or give me hints how to start ? for instance i have trouble with reloaded workflow I have added ring, jetty i cider-jack-in and the app works - great but when i make changes i have to cider-quit then jack-in again in order to have changes how do i make it nice so that jetty uses handler that is changed once it's changed hopefully my questions make sense

condp seems like a weird little function

Hey everyone! Does exist a function for compare list values?? I tried to use compare , but it does not work with a list

@tjb Following up on our discussion last night: https://clojurians.slack.com/archives/C0904S2QJ/p1582289250041300?thread_ts=1582275550.036400&cid=C0904S2QJ

ooooo!!!

thank you for the ping sean!

ok cool i was going with this too by having directories by domain

so my in case a directory would be called patent

which, if i am understanding correctly, lines up with Rick’s comment

is it typical to use a mocking library in clojure or do folks stick with with-redefs and write their own "fakes"?

(i feel like i have to question every convention i'm familiar with from java land)

there's a strong preference to stubs over mocks, but there's libs that do both

thank you @noisesmith i'll go in that direction.

also, the usage of immutable data and "mostly pure" functions means doing a lot less of either

if done properly

by "mostly pure" I mean segregating things that must do mutation (eg. IO) so that they touch as few other parts of the system as possible

that's definitely my intention. fewer tests and segregating pure/impure functions

I don't know about fewer tests, but definitely less need for mocking/stubbing when you use immutable data and non-side-effecting logic

most tests should look like (is (= {some data literal here} (f some input literal)))

i'm having some trouble using with-redefs across multiple namespaces. in the source code, i import a library (`clj-http :as http`) and then invoke http/get . can with-redefs target that get function, or should i wrap it in the source code like (def get http/get)?

it looks like there is a clj-fake-http lib for this, but i'm interested in working it out myself if possible

maybe another option is to import the lib using refer like [clj-http :refer [get]) but then i'm shadowing get

with-redefs can use qualified symbol names.

does qualified mean namespace qualified? naively, i've tried (with-redefs [sut/http-client/get stub-http-get but that throws unable to resolve var

(with-redefs [http/get stub-http-get] ,,,)

Just like you'd use http/get in your own code.