@bravilogy you don’t have to use it, but it prevents problems caused by global mutable singletons for application resources

that’s what I don’t really understand. how is a server instance mutable?

@bravilogy at one moment in time, it’s running and you can use it to listen for connections, at another moment in time it isn’t

at one moment, it uses your handler to serve requests - at another moment it has a different handler, or different middleware

it’s a resource that has state

how do we avoid the situation where your server is still running and you want a different one?

different server?

it owns a resource that comes from the OS, what if you replace the global reference before stopping it?

component helps streamline these things, not just for your server, but for other things that own limited or unique resources, or manage a mutable internal state

including database connections, or user state, or even graphic windows

what if one mutable or resource owning thing needs to access another one? component helps

hmm so it can be used on front end as well? in cljs?

I meant OS windows, but yes, I also use it in cljs

do you use it instead of re-frame?

doesn’t it have just start and stop methods?

@bravilogy another important usage is with tests - if your code is made to use components you don’t have to go redefining things in other namespaces to run tests - all you need to do is pass in data that is usable in the right way

@bravilogy I use it to control the websocket connection, and ensure that when things try to send to the server via websocket and the socket is closed, the messages get saved to send later, and that all the messages go through once the handshake is done

@bravilogy it ensures that the r/atoms that we create to manage state don’t have to be globals, instead they can be passed in from the component that initializes them on startup and owns them

if you have any public repos that show some simple usages, it would be very helpful to see please

similarly the router that acts on address bar changes - it gets passed routing rules via components, so that it doesn’t need to use globals and be tied to implementation details of the rest of hte app

@bravilogy sadly this is a closed source app - it’s the product we sell

but there are definitely examples of components out there, and they work on the same principles: if something is mutable or owns a limited resource, make sure it has a specific owner, isn’t global, and gets passed as an argument to things that need it

ok no problem 🙂 thanks for explanation. I think I’ll just need to see in action to actually understand what it does. I’m trying to understand it in other languages I know. perhaps it’s very Clojure related

how do the other languages work with limited or mutable resources?

maybe I should build this app from scratch and perhaps I’ll stumble upon the issue where I’ll have that ‘aah I see’ moment and use it

@bravilogy in my experience making something around a shared mutable global value, then trying to convert to use an explicit argument later, is a huge pain - it requires a lot of work

if you start with explicit arguments, it’s very easy to make it implicit (or even act like it’s global) in specific scopes if you later decide you need that

it’s not a two way thing - one way is easy, the other is hard

you mentioned the Websocket connection, so in simple terms do you mean that a mutable resource would be a global variable in js for example, that holds the connection instance?

yes - and attached logic that ensures that if some other part of the app starts to send, and we are not connected, the message is queued for later

and some data unpacking / packing, stuff like that

but when you use component, it’s not global any more

which means if you need to test it, or use things differently later, you can just replace an argument

instead of rewriting code or faking other namespaces or such

the way I’ve seen it written in some examples, it was assigned to something.. like (def system (create-system)) where create-system returned a component/system-map or component/Lifecycle

that’s convenient during development but isn’t recommended in an actual application

doesn’t that mean that system is global here ?

your code should not rely on that global

but it’s very useful to have that global in your repl

ah so in a production - ready application, I would have something like

(defn -main [& _]
  (let [config (config)]
    (-> config
        app-system
        component/start)))

in fact, it’s recommended to only create that def in dev mode, and simply anonymously create the system in prod, without leaving any handle to it anywhere

(copied from chestnut)

exactly

so basically it becomes just an argument to an application

component/start automates the start up order of the parts of the app, and makes sure they can see the other parts they need

damn 😄 I get it now

that’s another advantage, instead of having to mentally juggle the order that things start up because of functional deps, it can just do a topo sort of the tree of deps

you should write a blog post on this!

glad I could help!

maybe I will some day, heh

thank you so much

I guess I was complicating things in my mind

if you think about it, it’s providing the same advantages that fp does over imperative code, on an app architecture level

immutable arguments instead of mutable resources (or at least pretend, as much as you can 😄)

@bravilogy See if this simple example helps: https://github.com/seancorfield/clojure-webapp-live-demo/blob/master/src/webapp/core.clj -- it uses Component to start/stop a Jetty web server.

nice

thank you @seancorfield

I know about Integer. and Float. Is there a clojure function of type "string -> number or nil" which does if full string parses to a number, return number else, return nil

I always use #(try (Long/parseLong %) (catch Exception _))

or Double/parseDouble as needed

I was under the impressions that exceptions are slow and should be avoided for simple tasks, but I hnever benchmaked it tobe sure

catching that exception and returning nil is much simpler than a reliable maybe-read-a-number

and honestly since I only do that parsing at system boundaries, it is guaranteed to never be in a hot loop

so I haven’t had to think about its performance

I’ve got this 6 page SPA that I decided to re-build using clj + cljs. At the moment I’m using Node.js + Elm on that one and I’m so motivated to do it 😄 I’ve been playing around with clojure for a while now but haven’t built anything significant yet

if you think that your communication with the outside world is in a hot loop you need to optimize - statistically speaking it’s unlikely you shoudl be using clojure

is there a builtin for 'apply this function to last element of this vector' or is it a matter of peek, pop, and conj

is count on a vector guarnttted to be constant time ? https://clojuredocs.org/clojure.core/count says nothing

If I'm trying to compute f^n(x), is the best way simply (first (drop n (iterate f x))) ?

@qqq Here is the implementation of the method count() for objects of type PersistentVector in the Java source code for Clojure, which is the type that Clojure vectors are: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/PersistentVector.java#L205-L207

That is the method that clojure.core/count calls when you call count on a Clojure vector, because PersistentVector implements the Counted Java interface (through several intermediate subclass/implements relationships that I won't bore you with unless you want to know).

the fastest way to do this is going to be peep/pop, then transform, then push

So for probably all versions of Clojure up to 1.9, you are guaranteed it is constant time. Future versions? Only Rich Hickey knows 🙂

but really if you are asking this question, you are probably using the wrong data structure in the first place

if you’re doing something stack-like, use a list (and pop/peek/conj)

so I'm building a parser, where the tokens are stored in a vector

most of the time, it's just conj to end of vector, but occasionally I have to modify the last conjed token

well, I’d recommend: (defn transform-last [v f] (conj (pop v) (f (peek v))))

peek is definitely the fastest way to get the last element of a vector

got it; thanks

I'm trying to download a dependency, jai_core, from here https://repository.jboss.org/nexus/content/repositories/thirdparty-releases/javax/media/jai-core/1.1.3/. I added the repository to my project.clj like this :repositories [[["jboss-third-party" ""]]]. I still get an error message like this though Could not find artifact javax.media:jai_core:jar:1.1.3 in jboss-third-party ()

What am I doing wrong?

You need to request jai-core not jai_core

hm

I can't find any uses of jai_core though, I'm thinking this is a transitive dependency

https://mvnrepository.com/artifact/javax.media/jai_core/1.1.3 ah, there's jai-core and jai_core 🙂

Thanks for the tip

what's the cljs equiv of clojure.edn ?

do I need a separate library, or is this part of clojure?

it's transitively part of cljs

cljs.tools.reader.edn

or clojure.tools.reader.edn, as you prefer

#?(:cljs [cljs.tools.reader.edn :as edn]
               :clj [clojure.edn :as edn])

you can use clojure.tools.reader.edn in both clj and cljs

otherwise what you have is ok

yay for tools.reader!

I couldn't figure out how to start clojure 1.9. from the command line (sans boot tools) using java -cp because of the additional dependency (now that java -jar clojure.jar is not sufficient anymore). Specifically - which version of spec is needed for clojure-1.9.0-rc2? - is java -cp clojure.jar:spec.jar clojure.main the recommended way to start this? - is this documented somewhere? This would be a good candidate for the release notes as it might catch users switching to 1.9 unaware

hello, channel

> If you’ve spent years learning tricks to make your [multi-threaded] code work at all, let alone rapidly, with locks and semaphores and critical sections, you will be disgusted when you realize it was all for nothing. If there’s one lesson we’ve learned from 30+ years of concurrent programming, it is: just don’t share state. It’s like two drunkards trying to share a beer. It doesn’t matter if they’re good buddies. Sooner or later, they’re going to get into a fight. And the more drunkards you add to the table, the more they fight each other over the beer. The tragic majority of MT applications look like drunken bar fights. ~ http://zguide.zeromq.org/page:all

hello everyone, is there a function equivalent of haskells partition :: (a -> Bool) -> [a] -> ([a], [a]) in clojure?

@plins: https://clojuredocs.org/clojure.core/partition-by

@plins Not really, but group-by is close

@henrik, im not sure if ive understood the docs right

@pesterhazy two options: 1- use the new clj script 2- the just released 1.9.0-RC2 has a standalone jar, it's documented in the readme

(partition-by even? [1 2 3 4 5 6 7 8])
;=> ((1) (2) (3) (4) (5) (6) (7) (8))

id like 2 lists as a result

found the solution, ended up with (vals (group-by even? [1 2 3 4 5 6 7 8]))

group-by

yep

@plins note that using vals is probably incorrect

group by returns an unordered map

no guaranteed that you'll get [truthy falsy] vs [falsy truthy]

hmm

let me put my suggestion here, it’s now hidden inside a thread:

(defn haskell-partition [f coll]
  (map (group-by f coll) [true false]))

(haskell-partition even? (range 10))
=> ([0 2 4 6 8] [1 3 5 7 9])

this way order is guaranteed

thank you!

np

it is not always obvious that you can use maps as functions 🙂

Hm the rc2 link on https://clojure.org/community/downloads is broken

cc: @alexmiller

@bronsa, do you know if the standalone jar is published somewhere?

no

it's just a local build

as the build profile names suggests

Ah yeah, I need to update that page. This just changed as of yesterday.

We have a weird issue where some go routines stop working after about 5hrs - any ideas what we can look at ?

when I try to build the classpath manually I get Could not locate clojure/spec/alpha__init.class or clojure/spec/alpha.clj on classpath

look for blocking IO inside go blocks

will that hold up all the go routines though ?

blocking io is almost always the culprit

@len go routines execute in a shared threadpool

if you block all the threads available in that threadpool, nothing will gets executed anymore

it's just 8 threads even so it's quite easy to break if you're not careful

@pesterhazy how are you bulding that cp?

thanks folks - off to debug

@bronsa, I had a typo

it works now - here's a simple script to download clojure manually: https://gist.github.com/pesterhazy/afdfa47ac04d94ee16b5f2e8ddbb0bb1

don't do that

use the new clj script instead

no

why? it basically does that for you

I understand, but this is simple and I know exactly what it does - it's the moral equivalent of the standalone jar in clojure 1.8

clojure is just a jar, remember?

so what?

(or three jars)

meh

feels like NIH tbh

I don't see any point in reinventing something that has now an official impl

but you're free to do as you think best :)

all clj does is download your artifacts and build a cacheable classpath for you, nothing more than that or magical

clj is wonderful, but that doesn't mean that it's not useful to build a shell script to understand how it works

I'm not saying it's not useful to build a simplified version of X to understand how it works, I'm saying if you need to use it, it's probably better to use X instead. in this case, your script will break when clojure adds a new dependency. clj would handle that automatically

it won't break so long as I don't update the clojure version 🙂

Hi, is ex-info json serializable?

@decoursin ex-info can contain any java objects, so it depends on the contents

This doesn't seem to work:

(try (throw (ex-info "testss" {:a 3}))
                      (catch Exception e
                        (clojure.data.json/write-str (Throwable->map e))))
=> Exception Don't know how to write JSON of class java.lang.Class  clojure.data.json/write-generic (json.clj:385)

What about that case though ^

get it using ex-data?

Yeah, if I did that, I would lose the Message.

which in this case above is "testss".

it says right in the error message what the problem is

you’re trying to serialize an object of the class java.lang.Class, and your json writer doesn’t know how to do that

Ah thank you, it's a macro so I must evaluate it?

(try (throw (ex-info "testss" {:a 3}))
                      (catch Exception e
                        `(json/write-str (Throwable->map ~e))))

no, being a macro doesn’t have anything to do with it. (Throwable->map e) produces something that has a java.lang.Class object inside it.

Ok but then how can you json serialize a generic ex-info?

Serialization libraries generally have a way to teach them how to serialize opaque objects. cheshire allows you to extend a protocol to achieve that, not sure what c.data.json gives you as an extension point

Thank you, I see now that even a generic exception fails with the same issue:

(try (throw (Exception. "hi"))
                      (catch Exception e
                        (json/write-str (Throwable->map e))))
=> Exception Don't know how to write JSON of class java.lang.Class  clojure.data.json/write-generic (json.clj:385)

looks like they allow a protocol too

(extend-protocol JSONWriter
  java.lang.Class
  (-write [c out]
    (let [representation (do something to the class c)]
      (.print ^PrintWriter out representation))))

you'll need to import JSONWriter from c.d.json and PrintWriter from http://java.io

> clojure.core/Throwable->map formerly returned StackTraceElements which were later handled by the printer. Now the StackTraceElements are converted to data such that the return value is pure Clojure data, as intended.

^ Tidbit from the Clojure 1.9.0 release notes

Sounds good, thank you.

Is there something like promise where delivery can happen multiple times and deref just returns the last delivered value?

maybe core.async

but I want everybody to be able to deref, without emptying

atom and reset!

or any mutable value

mutable reference

that is just last write wins

the volatile reference might work great for that too

https://dev.clojure.org/jira/browse/CLJ-1512

but atom reads don’t block and I need that too

I think the implications behind "delivery can happen multiple times" rule out volatile. sounds like an atom though

hello everyone, id like to to spawn 4 threads in paralallel to do some IO, i dont need to get data back from those threads, whats the best way to achieve this besides

(thread ....)
(thread ..)
...
(thread ...)

"delivery" just means a write

I need the deref to block

like with promise

I could use a promise with an atom, that would work

and double deref

I meant that "delivery can happen multiple times" says to me that it's multithreaded, meaning volatile is a bad choice 🙂

if you are already using core.async (which I guess you are from the use of thread) I would look at pipeline-blocking

@hiredman, my mistake, i was talking about clojure.core/future which spawns a thread .. do you think its worth to turn my vector to a core.async queue and use pipe-line blocking

?

it depends, I might start looking at using Executors directly too instead of using clojure.core/future

like, do you want to have 4 threads that a re-used for doing io, or do you want to spin up 4 threads each time, does the io return a result, and do you need those results in order or not

i trully dont care about the result, and i wont reuse anything, those threads perform their work and die silently

This works I think.

(let [p (promise)]
  
  (defn last-val [] @@p)
  
  (defn reset-val! [v]
    (or (deliver p (atom v))
        (reset! @@p v))))

(future (println (last-val)))

(reset-val! 10)
(reset-val! 11)

I feel like I'm missing something simple here, but has anyone ever implemented a file-tailing algorithm in Clojure? That is, as new lines are written to a file, you process them in your Clojure code? It seems that just opening a reader gets me a snapshot of the file at opening time.

there are promise-chans in core.async that kinda resemble this

you can fulfill them once and they provide their value immediately forever

@ghadi I need to ‘fill’ them multiple times

I'm with hiredman, sounds like last-write-wins with an atom

@ghadi I need to block on the first deref when it’s still not initialized.

promise an atom?

@ghadi See my above code. It’s the other way around. Promise in atom doesn’t work, because you can only delivery to a promise once.

I guess that's your example above. Seems like the xy problem -- I need to know why

Yeah, I might not need it, I’ll think about it some more. thanks.

@borkdude what about checking if the atom is nil, and if so putting a watch on the atom that triggers your thing if the new value is non-nil, and then removing the watch inside the watch callback?

or maybe you even want to always want to ignore the current value, and only run your action when the value changes, and add-watch is what you want directly

> what about checking if the atom is nil this is hard to make thread safe without compare-and-set! I don’t need a watch.

the xy about this: I need to prepare some data in the background and I want the first web request to wait for this thing to be ready. It might be refreshed later.

with a watch, you can ensure your code doesn’t return until the value is ready

or, use an agent instead of an atom and use await

(well, watch plus delay or promise you can block on that is)

and really, if all you need is to prepare data in the background, why not just use future ?

> just use ‘future’ a future cannot be updated

why does it need to be updated? why can’t you just make a new value?

and if you have async updates multiple threads wait on, that would happen repeatedly, await on an agent sounds like it maps directly to that

(def a (agent)) (await a) ;;=> nil

right, there are no pending actions on it

atom and swap! with clojure.lang.PersistentQueue

oh crap, I was on history

forget that

Maybe we should switch to a thread as to not flood this channel with this topic, it’s getting kind of long

(.setLevel (Logger/getLogger "org.flywaydb") Level/WARNING) this works (silent DEBUG/INFO logs) unless add to project.clj [org.slf4j/slf4j-simple "1.7.25"]. How can i make silent this logs?

Is there a reason why zipmap doesn’t a transient under the hood?

probably not, there's a few places in Clojure that could still use some transient love

yeah I think a patch with benchmarks for that would probably be accepted

I ran a quick benchmark and for 1000 keys there’s only a drop from 250 to 213 ns

Probably because creating a new map from an existing map using assoc is very efficient already

yeah I got a measurable difference but not a particularly important one

I tested this because I wanted to know the performance difference between using map literals and zipmap:

(def f (fn [[a b num]]
    #_=>         {:a a
    #_=>          :b b
    #_=>          :num num}))
(def g (partial zipmap [:a :b :num]))
(quick-bench (f ["a" "b" 1])) ;;=> 22 ns
(quick-bench (g ["a" "b" 1])) ;;=> 250 ns

there's a ticket for this already

https://dev.clojure.org/jira/browse/CLJ-1005

There was a ticket for making merge faster CLJ-1458 but it could use some love, starting with a decent set of benchmarks

I would like someone to give that a whack. Keeping in mind that merge 1) preserves metadata 2) and because it is based on conj, happens to take either a mapentry, vector, or maps as arguments

(merge {} [:a :b] {:c :d}) => {:a :b :c :d}

need to go back to basics with that ticket and just start with a benchmark harness.

https://dev.clojure.org/jira/browse/CLJ-1458

Oh why am I talking with prose: @alexmiller do you have a spec lying around for c.c/merge?

wow, I'm pulling my hair out over this issue, when I create a reader at the repl this form parses correctly, but when I call a function on the form it throws an error. I'm about to hit the road so hopefully the comments on the ticket are clear https://github.com/gdeer81/marginalia/issues/165

it's such an edge case but I can't let it go

;; A symbol string begins with a non-numeric character and can contain
;; alphanumeric characters and *, +, !, -, _, and ?.  (see
;;  for details).

I would expect : inside a symbol to work by accident, and any bugs caused by having : in a symbol to be the fault of the one naming the symbol

Symbols beginning or ending with ':' are reserved by Clojure. A symbol can contain one or more non-repeating ':'s.

well, time and again, in these kind of discussions a distinction has been made between legal symbols and readable symbols

right, but those docs seem to say that a single : in a symbol is readable

(and also legal)