does anyone knows of good examples of apps that support oauth2 authentication (for example with Github)

I'm trying to add authentication to a project of mine and wanted to get some ideas for example about how to structure the database, how to use it with Ring etc etc

I've been wrestling with how to implement a new Exception subclass using AOT compilation to make it accessible from both clojure and as a Java library. Am I overlooking something?

(ns execution-tracing.execution-id-too-long-exception
  (:require [execution-tracing.core :refer [maximum-id-length]])
  (:gen-class
    :name executiontracing.ExecutionIDTooLongException
    :extends IllegalStateException
    :state "id"
    :init "init"
    :constructors {[String] []}
    :methods [[getMessage [] String]]))

(defn -init [id] [[] id])

(defn -getMessage [id]
  (str "Execution ID exceeds maximum length of " @maximum-id-length ":" id))

I'm currently getting java.lang.ClassNotFoundException: executiontracing.ExecutionIDTooLongException, compiling:(core.clj:1:1) whenever I attempt to start a repl in this project.

The best way to do this is to write it in Java

Is it not possible to do via Clojure? 😕

it is possible but often not worth the hassle

does an ns declaration with (:gen-class) even generate a class while REPL-ing?

I thought it required AOT compilation

it doesn't generate a class while JITing indeed

that's why it's failing for @jmromrell

gen-class requires AOT

So, assuming I am wanting to keep this library in Clojure, the solution is to publish a Java library containing only the exception I need, and then depend on that? Or is there a way I can directly package the Java .class or something with the clojure library?

you can use lein javac

and package the java file with your clojure lib

or, if possible, you should consider not subclassing exceptions and using ex-info instead

All right, that isn't too ugly, at least. I might poke around and see if I can get the project to work as-is if I define the exception class in Clojure as well as using gen-class (potentially fix the current resolution error via clojure repl, while still exposing a definition that can be used by Java library consumers)

I have kind of a silly question. I recently started using datomic, and everything is wonderful… except that I end up doing stuff like this:

(-> (d/q '[ ... query that should only return one value ... ] (d/db dconn))
    (first)
    (first))

is there some idiom for getting the value out of a query like that?

ffirst or datomic Scalar value (ends with .)

great! thanks 😄

Hello there, I’m writing a for-fun app to send me slack cat gifs at a random time between 12pm and 5pm. In so far I’ve got a channel emitting the current date every second but I’m curious if there’s a better way to model this logic with core.async.

@jayzawrotny one method is having a function that output values at random times onto a channel:

(defn randomly [outc]
  (go-loop []
    (<! (timeout (rand-int PERIOD)))
   (>! outc :tick)
  (recur)))

Ah that makes sense! Though I’m not sure I fully understand how your notion of periods\integers would work with that. Perhaps generate a random timestamp then calc the difference between that target and now to get the number of ms to set the timeout for?

the process is going to sleep for an indeterminate amount of time (0 < x < PERIOD)

no need for timestamp calculation, IMHO- but you can certainly calc to get more specific

I think I see, however the value of PERIOD depends on when randomly func is called doesn’t it?

PERIOD should have been a parameter 😉 I was pseudocoding. randomly would only be called once and would run forever in the background

Ohhhhh

So period would hypothetically be the number of ms between 18 - 24 hours from now?

(let [ticks (chan some-buffer)]
  (randomly (* 60 1000 10) ticks)
  (cat-gifs ticks))

period would be the max duration between cats

yeah it would be the number of millis between ticks, on average

"pulses" of the trigger

(there are other ways of approaching this problem)

Cool, I gotcha. Agreed, I’m very interested in how other devs would solve this while keeping the trade-offs in mind 🙂

I think yours is a very elegant solution but my understanding is that because it’s interval based the channel would need to be started within the range of the target time for it to hit the correct time window. Am I missing something?

in my book it is important to keep the stimuli (the pulses) and the action based on the stimulus (sending a cat gif) separate

I think you're missing that i'm suggesting deferring the determination of the correct time window to the consumer of all the pulses

ignore/drop a pulse if it's outside the time window

Ah sorry

Ohhh!!! I see now, yeah that could be way more robust!

having the separation between stimulus / action can help iterate on both sides of the problem

you could improve the consumption of the pulses... or produce more specific pulses

you could do something more specific with https://docs.oracle.com/javase/10/docs/api/java/util/concurrent/ScheduledExecutorService.html

without core.async

And the pulses are more general, in which a consumer can check the time against the target window (or w\e conditional) and send the next gif.

yup

the pulse itself isn't meaningful, just a value :tick

In which case, why randomize the pulses?

you don't have to. s/randomly/periodically

another example of creating a separation and iterating on both sides ^

Thanks, I’m looking at it now. The randomness would ensure that the times a cat gif is sent isn’t too patterned and predictable.

Ah yeah the queue scheduler could work too

Is there a more clojure idiomatic way to work with the scheduler queue or would it be basic java interop with (shceduler\scheduleAtFixedRate time-test-fn, 0, PERIOD, scheduler/SECONDS)?

basic java interop

The goal is really to learn with this project so may as well try a few of these designs and see what works the best. Thanks again for the help

When / why use deps.edn? Can you recommend article to read which explain details in friendly way?

as far as I know, CLI tools are more limited than lein/boot options.

right, deps.edn cli is only for dep resolution, it doesn't do project or build features and doesn't have a plugin system (but people have tried to add extensions that build those features over in - they will never be part of the tool itself though)

So why / when to use them?

if all you need is to pull in dependencies and you don't need to build, deploy, package, add dev tooling, etc.

deps.edn is useful on the cli for test cases and sample code

(or if you prefer the ad-hoc system being built around deps.edn rather than a unified tool)

No longer need English instructions or a full project.clj for a runnable example

So… it sounds like it could be useful only for libraries? Like CLJJS wrappers

I don’t feel it 🙂

https://clojurescript.org/guides/webpack is it possible to not use deps.edn in this example? Instead use project.clj? I am trying to run it, but I have error:

aused by: clojure.lang.ExceptionInfo: No such namespace: reagent.core, could not locate reagent/core.cljs, reagent/core.cljc, or JavaScript source providing "reagent.core" in file ...

well actually it happen during clj -m cljs.main -co build.edn -v -c which is something new for me

if you are trying to do web development with Clojure(script), my recommendation is to start with Luminus

it will give you a full app skeleton

I want to use npm dependencies. Hmm probably this part I should discuss on #clojurescript 🙂

@kwladyka that’s what I was about to suggest

But what about this question? https://clojurians.slack.com/archives/C03S1KBA2/p1536085084000100

I mean this part about not use deps.end, but project.clj instead

I'm developing a Web app , this my project file, maybe could be useful: https://github.com/aarkerio/ZentaurLMS/blob/development/project.clj

@kwladyka so you can use project.clj

but you are going to have to create an alias

to run cljs.main

does that make sense?

project.clj will handle setting up your dependencies

yes and no, I don’t get it why in this example Nolen use deps.edn

clojurescript is obviously dependency when writing cljs code in project.clj / shadow-cljs.edn

@kwladyka :aliases {"cljs" ["run" "-m" "cljs.main" "-co" "build-edn" "-c"]}

@kwladyka I think you are missing some major things

I am sure about it! 🙂

deps.edn specifies your dependencies

clojurescript is one of your dependencies in this case

the guide plainly specifies a deps.edn file

wether or not it should be their is a much bigger topic

if you have other dependencies they also have to be in the deps.edn as well

clj does not pick up your dependencies from your project.clj

yes, but assumption is everybody will use project.clj / shadow-cljs.edn in project anyway. So why this deps.edn file? What a value for that? Is it necessary from technical point of view? Why not remove this deps.edn?

everyone does not use project.clj

people use deps.edn instead of project.clj @kwladyka

and shadow

deps.edn replaces project.clj

http://figwheel.org

why deps.edn should replace project.clj?

if you are using leiningen, then keep using project.clj If you are are using the new clj command-line tools, you would use deps.edn

you can have a fabulous fast clojurescript workflow with out leiningen

hmm I think I really miss something in Clojure community about this deps.edn

So while you use deps.edn how do you compile your code? by lein / shadow? What is the point then?

Can you recommend something to read? I didn’t find anything which explain it for me.

https://clojure.org/guides/getting_started

https://clojure.org/guides/deps_and_cli

https://github.com/clojure/tools.deps.alpha#rationale -- there are a few links there, I'd start with the Guide

one of the strategic moves that tools.deps + the clj tools unlock is Non-Artifact Based Development. Instead of having to bundle everything into a Jar / artifact and deploy that, then bump dependencies, you can refer to a git SHA instead

comparing lein vs deps.edn isn't apples to oranges, lein is like a swiss army knife. deps.edn Sets Up a JVM classpath and launches a JVM... that's it.

so -- clojurescript compilation isn't something that is in scope for clj/deps.edn, but setting up an environment where you could compile clojurescript definitely is

Hmm so what was the intention to make deps.edn? git compatibility?

to make sure people could just start up clojure 1.9 without a project manager

since it depends on another jar

that, too.

lein's dependency / profile handling is... weird, to say the least

but yeah, moving beyond maven, clojure 1.9 requires multiple packages, etc.

What about all lein plugins / solutions etc.? What do we have with deps.edn? Is it something what we should use in new project over lein?

Out_Of_Scope

hmm and what with build.edn https://clojurescript.org/guides/webpack . I see it is supported by this new solution. So it also can compile code.

*new solution clj instead lein

clj is not intended to be a replacement for Leiningen or Boot. I am not familiar with all of them, but people are developing programs that can create the dependencies part of a Leiningen project.clj file from a deps.edn file (corrections welcome on the details there, since I haven't used them) and maybe also the other direction. clj allows you to specify dependencies that Leiningen cannot, e.g. to specific versions of source code in a Github repo.

Can I simplify it to this sentence? deps.edn is designed to manage dependencies and this is the right place for it. It should be there over lein / boot / shadow-cljs. But other things like how to compile the code etc. should be in lein / boot / shadow-cljs? The intention is to make Clojure dependency manager independent from other solutions. Split dependencies from tools / compile the code.

Ok it is longer sentence than I expected 😉

So should we prefer to use deps.edn over deps in lein?

@kwladyka I'll also offer an observation that some Clojure shops (including where I work) had elected to put dependencies in external EDN files and use version overrides, via custom machinery prior to deps.edn / clj -- we happened to use Boot but I've heard of folks doing it with Leiningen as well (it was more common with Boot tho' due to how programmatic it is, compared to Leiningen).

There are plugins/tasks for both Leiningen and Boot that let you use deps.edn (and tools.deps.alpha) to provide additional functionality on top of clj's core abilities.

I think for any new project I was starting, I would go with deps.edn and clj plus associated tooling (like depstar maybe)... and only go to Boot (or Leiningen) for a task that was outside that ecosystem (although I can think of anything right now -- unless I still needed to conform to the deploy-to-Clojars model for some reason, rather than "encouraging" folks to use GitHub as a dependency).

@kwladyka I think people might hesitate to tell everyone else that they should prefer to use deps.edn over deps in lein. If someone is happily using Leiningen and it meets all of their needs with no changes, why would I presume to tell them they should change that?

deps.edn made a hell of a lot more sense when I started using Datomic ions

@kwladyka also some more context, there's a "basic repl" provided by "cljs.main" described in the new cljs quickstart. This setup sits on top of the new tools.deps infrastructure. Most people will end up using figwheel.main or shadow, sitting on top of the new tools.deps infrastructure. However, when someone from the core team produces a new guide or tutorial, more often then not, you'll see them built on top of the simpler, generic "cljs.main" basic repl. This is so that the core team can focus on fixing problems related to core, rather than the (hopefully) thousands of tools that want to build on top of it.

So, if you want to use the webpack tutorial, for instance, you're going to have to translate that to your tool of choice (which will hopefully be an expanding field of choices)

(or not, some folks think too many choices is bad)

I think we don't need any more "comprehensive" build tools -- Leiningen and Boot are more than enough -- but I think there's plenty of room for small/narrow, focused tooling, built on top of deps.edn etc. I think the new tools we see here https://github.com/clojure/tools.deps.alpha/wiki/Tools is encouraging.

what would be an elegant way to split a vector into two vectors, one containing the even-index items other odd-index items?

so far I have partition 2 followed by mapv first and mapv second.

`(vals (group-by odd? (range 10)))` (I have a reading comprehension problem 😆)

@roklenarcic be aware of how partition works when it can no longer fill up an entire partitioner

(partition 2 [:a])

I check for that explicitly

another solution that doesn't involve making a new vector but rather sequences

is to use range with step of 2 and nth

thank all of you for answers 🙂 🍻

As anyone tried hyper-deep code-walking ? A typical code walking situation is that of a macro that accepts arbitrary code and performs transformations at arbitrary depth in its tree-like structure. Now imagine that additionally to this the macro figures out which functions are called, get their source code, deep-change it so as to define clones, and so on. Is this a thing in Lisp ?

so treat every function as a macro?

somehow yes

using tools.reader as a basis (either to use directly or fork of off) I am sure it could be done

The core.async library does transformations at arbitrary depths of the tree-like structure of code within single functions. I am pretty sure it does not do so across function boundaries.

@andy.fingerhut does it do this by defining its channel ops as macros, or is there a deeper magic going on?

how does one produce a quoted form inside a macro? Specifically I’m trying to embed a Datomic query (`'[:find ?foo ...]`) in a macro, but I’m doing it wrong

hmm, (quote ~'form) worked. Is that correct?

as a literal or something passed in?

a literal, literally [:find ?stuff ...]

in that case (quote form) should suffice

didn’t seem to; the meta-vars ?stuff for datomic turned into the.ns/?stuff

oh, inside backtick, that makes it harder, yes

so yeah, yo want ~' on each of those symbol literals, or once on the whole form

hmm, so this works too: '~'[:find ?blah ..]…

right, 'foo and (quote foo) are always equivalent

the reader does that transformation when consuming your code

@noisesmith I think core.async is adding each form to a stack, sorta like a promise chain

as far as I know it only does that for the channel ops though - but I guess that would mean that instead of expanding the forms it does a transform on that line and the ones following when it finds them

core.async's go macro operates like a compiler for a lisp, it is just that the source language and the target language are very similar. it does macro expansion (using the macro expander from tools.analyzer) and then code generation

the channel ops like !> and <! are special forms in the source language that the compiler knows how to generate code for

the macro expansion is fairly vanilla, and pretty much the least interesting part of the thing

Is it every line or do you consecutive lines get bagged up until we reach a transforming function?

after the reader reads, you have datastructures, there are no lines anymore

yeah, I mean consecutive forms/structures

the go macro only operates on the arguments to the go macro

And the arguments to the go macro can span pages of code, if one were so inclined to write code like that.

So every form unwinds due to macro expansion, then they all become args to the go macro?

the go macro takes a & body

so it gets a datastructure (seq) of whatever datastructures the reader created

I'm guess it collects forms until it hits a blocking op, then shelfs all collected forms in a closure, throws it on the stack, then starts collecting again

clojure macros are arbitrary functions, so they can do whatever even "hyper-deep code-walking" whatever that is, but macros are purely about transforming syntax. many people new to macros think "oh, I have this hand wavy thing I haven't defined, maybe macros will help". It never does. Macros can give you a nice syntax on top of whatever semantics, but you have to come up with and have a good set of semantics and know how those semantics are represented without macros first.

sort of, but actually all the code ends up a single closure in a case expression

the transform for the go macro is actually very similar to anf

Tim has some amazing videos on YouTube about these macros