thanks!

ex-info is usually used to pack in more info along with the exception. You can retrieve the info back with ex-data. https://clojuredocs.org/clojure.core/ex-info https://clojuredocs.org/clojure.core/ex-data

Yup, what he said. ex-info is designed for "information-bearing exceptions" and this sounds like a good fit.

(and the latest version of Clojure adds ex-message as a standardized way to get the message from any exception)

If ex-info is for information-bearing exceptions, the answer for non-information-bearing exceptions are classic java exceptions?

(of which I don't know any)

What I mean, is that when throwing my own errors, are there situations where I should use java exceptions (like this one for example https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/NoSuchFieldException.html), or should I always use ex-info for my own exceptions?

It depends. You could, e.g. thrown an IllegalArgumentException when you receive an invalid input data although it's not very common. However, if you feel like you want to create your own exception class then you should use ex-info instead, imho.

@U7S5E44DB if an existing Java exception matches the problem you want to report -- and you don't need to convey any additional information -- them it's reasonable to throw the Java exception.

Just remember that exceptions are not intended for "expected error conditions" or flow of control -- they're for "I can't handle this!" situations.

awesome advice everyone! i was looking at ex-info yesterday and it does throw the exception with the info i provided however i would like the exception thrown and also a response like

{ 
   "status": "4xx",
   "message": "My Custom Message Here"
}

does that make sense? if not i can add more details tonight!

d’oh!!!!

ex-data is probs what i need as mentioned above!

i will try that and report back!

I think ex-data is what you need. Whatever you return from the HTTP handler will be sent back to the browser.

perfff!!!! ill give it a try tonight and report back!

again the cloj community helping me out as always! so excited

ok so after looking at this more i THINK what i really want is clojure's spec functionality to do validation on incoming client requests

@U0D5YAGUX That's one of the ways we use Spec -- we write specs for our API's input parameters and then we s/conform the params and check if s/invalid? -- if it is, we respond with an s/explain-data mapped to client error messages, else we used the conformed parameter data.

We opened sourced some of our low-level spec utilities for dealing with API parameters https://github.com/worldsingles/web-specs

@seancorfield do you have any examples of how to use web-specs?

(s/conform ::some-spec some-value)

Then check s/invalid? on the result. Just like you'd use any other spec.

Not sure what to say beyond that. They're just specs.

@U0D5YAGUX Have a look at the tests and let me know if you still have questions https://github.com/worldsingles/web-specs/blob/master/test/ws/web/spec_expectations.clj

You can also use s/valid? with the spec directly, but that doesn't give you any conforming of input data.

(defn expensive-computation* [_ a b c] ...) (def expensive-computation (memoize (fn [a b c] (expensive-computation* *rte-known* a b c))) perhaps?

If I understand your problem correctly then you can bind the dynamic variable to an e.g. atom to hold the computation state

@UTQEPUEH4 looking at the implementation of memoize, I doubt your suggestion will work. It seems memoize creates a closure, which closes over an atom on which it uses as a memoization table for that function. this memoization table remains until the closure is garbage collected, if ever. It is not recreated and released when the user binds a particular named variable.

in stead, according to my interpretation of the function, if the value of goes out of dynamic scope, then these values will stay in VM, memoized on that secret atom, until the JVM session ends.

@UKQS17P3L, I think that means I'd implement a macro for the user to use to rebind the value. the user would not call assoc directly, but would call my with-known-values macro.

it's a good idea, saving me the effort of implementing a memoization protocol.

Cool glad I helped

Glad I asked this question, as I didn't know about memoize, and its a function I've written from scratch multiple times in other lisps. The documentation says it is used to memoize the return values of a pure function. However, the introduction of a dynamic value violates this assumption. i.e., the return value now depends on both the arguments and the dynamic extent.

Of course the memoization store remains; but if your dynamic var has changed since something was cached there, those cached results will not be used for the next calls

I've got the code wrong though, of course. Should be something like (def expensive-computation* (memoize (fn [_ a b c] ....))) (defn expensive-computation [a b c] (expensive-computation *your-dynamic-var* a b c))

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

addition and subtraction can just be functions

calling a function with is calls inside inside a test just works

calling a deftest inside a deftest seems like it would never be a good idea

That example was straight from the DEFINING TESTS section of the docs

which docs?

https://clojure.github.io/clojure/clojure.test-api.html#toc0

Maybe I misunderstood what they were saying. Functions work fine.

right - I think functions are more likely to allow the behavior you want, I can't think of a usecase where you'd both define a test (which means clojure.test would run it when testing an ns) and also call it from another test

unless you were using binding to set dynamic vars, or calling tests from another ns

That is odd that that example is in the docs.

So how would you have nested tests, if deftest isn't the way to go?

From the docs:

(deftest arithmetic
  (addition)
  (subtraction))

I don't understand the premise, I have never needed a test that invoked other tests, I use the testing macro for that

(ins)user=> (source clojure.test/testing)
(defmacro testing
  "Adds a new string to the list of testing contexts.  May be nested,
  but must occur inside a test function (deftest)."
  {:added "1.1"}
  [string & body]
  `(binding [*testing-contexts* (conj *testing-contexts* ~string)]
     ~@body))
nil

OK, that works. Thanks.

I dunno how I missed that.

Really I just want to group similar tests together. I may have confused myself with the examples in the docs.

From the deftest docs: > > Usage: (deftest name & body) > Defines a test function with no arguments. Test functions may call > other tests, so tests may be composed. If you compose tests, you > should also define a function named test-ns-hook; run-tests will > call test-ns-hook instead of testing all vars. Suggests you create your own function test-ns-hook to call just the tests that should be called, to avoid double running.

ah that was the piece I had missed

It was well hidden 🙂

I ended up doing something akin to

(deftest related-features
  (testing "Feature A"
    (test-feature-A)
    (test-feature-A-adjacent))
  (testing "Feature B"
    ...))

Thanks so much @teodorlu, that's really helpful!

I mean, these are just examples. Actually I want to share a websocket connection with two functions.

But I don't want to leak the connection to other methods.

the idiomatic thing is to make x a def - normal clojure code doesn't do much data hiding

if f and g should be so tightly coupled, make them methods on a record or type

making a websocket connection a global (a def) is very suspect

In (swap! (atom 0) max []) args is not [] , but [[]]

because args is the list of arguments, and your list of arguments contains one thing (an empty vector)

ah right, thank you

I want to use (apply swap! ...)

probably not, you want to use swap! your-atom max (if you really want to call max with just one argument, that is the value of your atom)

I find it strange though; can you describe what you are trying to do?

if you have a coll and want to swap! to assign to the max of current value / values in coll, (apply swap! a max coll) makes sense

(cmd)(user=> (def alternates (repeatedly 10 rand))
#'user/alternates
(ins)user=> alternates
(0.9628561654175068 0.11902505003214825 0.3835041588382112 0.5507751502080879 0.18499959134452892 0.013132287289970068 0.00873908073221663 0.890933501821531 0.8008623048866589 0.9502918850062402)
(ins)user=> (def a (atom 0))
#'user/a
(ins)user=> (apply swap! a max alternates)
0.9628561654175068
(ins)user=> @a
0.9628561654175068

yup, that's precisely what I'm doing!

what are (cmd) and (ins) in this prompt?

kind of looks like a pasting artifact from emacs?

my readline config asks for the vi mode of my prompt to be visible

it saves me typing extra esc / i to be sure of my mode

this is fundamentally opposed to the premise of lein (and other m2 based dep managers like maven, gradle, and deps.edn) the goal is that every dep is project local and versioned, so you never break a project by changing a dep for another project, you can't do this if you are using global installs

that said, you can create a profile in ~/.lein/profiles.clj that automatically includes the deps you want when experimenting and not committed to a specific project

that way you can opt-in via lein's with-profile to add the deps to a repl, without polluting all projects

In the case of cljfmt, the readme describes tools.deps settings that can be wrapped in an alias/script and used independently of lein

% cat ~/bin/cljfmt
#!/bin/sh
clojure -Sdeps '{:deps {cljfmt {:mvn/version "0.6.4"}}}' \
  -m cljfmt.main $*
% cljfmt check core.clj

and tools.deps / deps.edn has its own user config for opting into a set of deps for your repl or task via a profile (using the terse -A flag instead of lein's verbose -with-profile)

A util that added the latest dep version as a line to your deps.edn or project.clj might be a nice convenience

% cat ~/.clojure/deps.edn
{:aliases
 {:cljfmt {:extra-deps {cljfmt {:mvn/version "0.6.4"}}
           :main-opts ["-m" "cljfmt.main"]}}}
% alias cljfmt='clj -Acljfmt'
% cljfmt check run.clj
...

So there are a few issues here that have been brought up. However, my original question was not relating to those (although thank you for the information). The two issues are: 1) Global vs Local installs. Sorry I was not clear, but I was explicitly referring to Local dependencies and the convenience of installing them via command line. In other words, I was hoping there was a simple lein task/command to install local dependencies in your project.clj via command line. Ala npm npm install react This automatically updates the project-local package.json with the latest react package dependency. Similarly I was hoping something like: lein install clfmt Automatically updates the :dependency value in project.clj with the latest version of cljfmt However, there doesn't seem to be anything like this (at least from what I've googled). Which is a bummer

To the latter point, I have seen lein ancient https://github.com/xsc/lein-ancient that can find deps in your project that can be updated. As to adding deps from the command line... it just doesn't seem like something lein is trying to be. But lein is also extensible; maybe someone has/will do it in a plugin. :man-shrugging:

this tool seems to do what you want for deps.edn https://github.com/hagmonk/find-deps

and you can tell lein to use deps.edn, so that should be what you want? add find-deps to your personal deps.edn under the alias find-deps then follow the instructions on the readme

nice. Thank you, I will take a look!

@U050MP39D Which editor do you use ? 2/3 months ago I was looking for the exact same answer and today I actually use find-deps but also clj-refactor in Emacs / CIDER which allows me to add the libraries via the cljr-add-project-dependency command like this:

By the way, it works for Leiningen and project.clj too

Direct visualization in GIF

if I were writing enough clojure to warrant it I'd be using cursive. but atm I just use command line repl + occasional vim, so find-deps via clj -A:find-deps -F:save works for me

Also, for very simple GUIs, Seesaw works pretty well: https://github.com/daveray/seesaw

@U47G49KHQ I think #1 should be investigated further. My gut feeling is cljfx wouldn't use as much CPU, and memory should be a constant overhead, but might be wrong.

memory is constant, but for small apps in electron it’s 100mb, and in cljfx its 800mb

study with n=1

I've had REBEL run with Xmx50mb

nonono

you can run cljfx with Xmx50mb

it will limit the heap size, but jvm internals will still use half a gig

Well, when I measured the process as well I never saw it go beyond 100mb

maybe that part can also be limited, but I haven’t investigated that further

I know, because my laptop only has 4GB RAM, and no swap 😛 I can't even run Google Chrome without it trashing

So I use Firefox, and can't use VSCode or IntelliJ, need to run Emacs

hmm, have you tried running cljfx/hn?

No, I should try

https://github.com/cljfx/hn/releases

it could be that jvm limits it’s internal memory use depending on available memory…

Hum... REBEL is only delivered as a JAR though

And I have the Zulu JDK with JavaFx included

the differentiator for membrane is that many other gui libraries start with some underlying tech (javafx, the DOM, swing, cocoa, etc) and build up. membrane tries to take th opposite approach. think “what would be the ideal?” approach and build down. think it of it like ring for guis. the same ui code can the run on top of multiple implementations

so it’s in a weird spot where it’s not mutually exclusive with other frameworks and libraries

I think that approach might have some drawbacks: it has to be lowest common denominator, right?

btw, I’ve been recently checking out cljfx and it’s very cool

@U0K064KQV you could try clj -Sdeps '{:deps {hn {:git/url "" :sha "d3bbccb9fd6ebc6e278bdf0dc3f49351d826025c"}}}' -m hn.core

there’s nothing getting in the way if you want to have platform specific specializations

Might prefer that, also because you have a deb package and I'm on openSuse :S

and if we’re comparing it to the DOM in the browser and javafx, then we’re already in lowest common denominator territory

> there’s nothing getting in the way if you want to have platform specific specializations but then you are effectively tied to that platform?

or you need to reimplement this specialization for different platforms

yes, that’s the tradeoff, but since the whole stack is in clojure, it’s a lot easier

hmm, I think that might be useful when you need to target multiple stacks at the same time

but i’m totally with you on getting a lot of push back from the crowd that’s used to the web

we’re on the same team!

Hum, so it was consuming 650mb for me on normal

And OOTO at Xmx100m

ouch

you mean OOM?

what’s OOTO?

oups OOM

yes

At Xmx300m it seems to work, but ya, total memory in OS is still around 650mb

even then

Now I'm wanting to double check rebl, maybe I have my data wronf

please do!

Hum, so REBL does run with Xmx100m, and doesn't OOM, but you're right, process memory is still around 600mb

thanks for verifying! I think cljfx/hn might OOM depending on the size of pages you open, since it additionally embeds a browser…

Ya, REBL is a pretty lgihtweight app in comparison to having to render web pages

I guess JavaFx is a bit of a resource hog 😛

Still planning on trying out cljfx

I think to me, a JVM based option does feel an easier environment then trying to do Electron

Just getting Java's api to interact with the OS

is a win

ok, going to bed, ttyl

The last point in your comparison might actually be in favor of cljfx (only half joking). There are less people to help maintain the project, true, but also less people making a mess and deviating from the founder's vision

Haha yeah 😄 It’s not like I’m discouraging contributions though!