Does deps have support for profile injection of code, similar to the same lein feature?

Couple of days ago I asked about ‘patterns’ here - I completely forgot that I have this on my bookshelf … https://pragprog.com/book/mbfpp/functional-programming-patterns-in-scala-and-clojure

#yada

Hello. Does anyone use Yada? Im trying to get started

what do i make of this?

According to my search on Bing, that's most likely due to IP6 vs IP4 issues @norilinoriginal

How are you starting the Socket REPL? What platform are you on?

Hmm...I am a bit confused on EPL / GPL incompatability that I am reading about. Statements such as "Clojure is EPL (1.0) and therefore any code written under GPL, but compiled with clojure libraries (even core language features themselves) is therefore impossible to distribute legally" (paraphrased) - yet, if I compile some C with gcc, that does not mean my compiled C code must be GPL just because gcc is gpl. So, why would compilation of a language (clojure) to java byte code imply that resultant byte code must be EPL?

Where did you read that statement? It doesn't sound right to me.

or, if I type code with Emacs, which generates code / text based on my interaction with the program, despite Emacs being GPL, it does not mean that my resultant source code is needing to be GPL

let me plop down some of the links I've been reading tonight

https://www.eclipse.org/legal/eplfaq.php#GPLCOMPATIBLE

https://www.gnu.org/licenses/license-list.en.html#EPL

it would be one thing if it was a user package like clj-http or jdbc or something that was epl and thus incompatible, because that would be closer to glibc and its LGPL license that accommodates gpl use (I think glibc is lgpl)

but to say, a core language would ban all gpl derivatives?

GPL is a very problematic language from a programatic point of view. Lots of other licenses are not compatible with it -- and it's the GPL's "fault" because it is, essentially, a "viral" license.

https://groups.google.com/forum/#!topic/clojure/TfPK-ljC46I

But I don't think code written in any of the GPL lisps requires the derivative work to incorporate the host language's license choice do they?

When I worked at Adobe, the legal team almost never approved use of GPL software if it might need to be combined with anything else (rather than just being a standalone tool).

guile-scheme is gpl right? but surely any scheme I write does not have to be gpl

It's nothing to do with that.

(maybe it does 🤷 )

It's to do with combining and distribution of code that is under different licenses.

guile is lgpl, so I suppose that's why it never has surfaced in things I've come across as a show-stopper as far as licenses are concerned

Your problem isn't Clojure being EPL per se, it's about combining and distributing bundles of code as derivative works.

ugh, what a cross-roads, when ideology meets preference - clojure is such a great language, but to use a language constrained by a license that forces almost all things built on it to match the same license - maybe a language built with all of its runtime as GPL would be in the same boat

but it seems all the "gpl" flavor languages+stdlibs use lgpl to work around that

The fault is GPL, not EPL.

so derivatives can be mit / bsd / epl -basically anything

you say potato, I say potato

🙂

EPL is very friendly to companies -- so Clojure is easy to use for businesses.

If you write software under the GPL, a lot of companies won't touch it (unless it is a completely standalone tool that they don't have to combine anything with).

If so, is there any chance I could get a license of your program under the Lesser GPL? You can ask, but most authors will stand firm and say no. The idea of the GPL is that if you want to include our code in your program, your program must also be free software. It is supposed to put pressure on you to release your program in a way that makes it part of our community. You always have the legal alternative of not using our code.

So - is it correct that if a company writes a commercial app in clojure, due to EPL, anyone they distribute it to would have to also distribute the source code?

No, absolutely not.

Datomic is closed source. REBL is closed source.

https://www.eclipse.org/legal/eplfaq.php#SOURCEWOBJ

Do I need to include the source code for such Program with the object code distribution? No. But you do need to include a statement that the source code is available from you and information on how to obtain it.

If I purchase dataomic or REBL, does someone tell me the source is available and how to obtain it?

No, those are not EPL-licensed.

That's my point, you can build non-OSS products using Clojure.

Are you sure the only reason they aren't subject to EPL is because Rich has a CLA for clojure? And thus full copyright of it?

he / owners of clojure code can relicense as non-epl their entire language, but only they have that privilege

This isn't about re-licensing Clojure.

so, a derivative work (dataomic) can ignore the fact its host is EPL

I feel like you are concluding things without actually reading or understanding any of the documents

`

"If I modify a Program licensed under the EPL and distribute the object code of the modified Program for free, must I make the source code available? Yes. By distributing the modified Program, even if it is only a free version of the object code, you are obligated to make the source code to the modified Program available to others."

Not intentionally - I have been digging through old postings but it would help if some official document / FAQ clarified all of this closer to the context

I read through the google groups posting and consideration of epl 2 (and rejection) and have been trying to do a thorough investigation - a few of my comments are conjecture / my own assumption yes

with respect to something like Datomic, that sentence starts "If I modify a Program"

Datomic does not modify Clojure and is not itself licensed under the EPL

Is this statement true or false - "Code written and compiled into the same JVM byte code space as clojure core is subject to the EPL 1.0 license"?

If it is false, then I believe if I use no 3rd party libraries, I can build a clojure GPL ecosystem

if it is true, then I can't

legally, there are a lot of clarifications to the definitions of words in that statement before it can be evaluated

and the notion of "linking" in particular with Java bytecode is a particularly thorny one

if the clojure jar functionality (the language primitives) are extended with user defined code, even as simple as a "hello world" main call - isnt that a modification of the original program?

because the program and what it does when executed has now changd

The vast majority of people building stuff with Clojure are not "modifying the Program" because they are just using Clojure as-is.

I would say no

it may not be a modification of the source files

if I #include <gpl-library.h> in a C program and write my own functions extending it

thats not a modification to the gpl program?

I'm not qualified to answer that question

I'm sorry if any of this is coming off trollish, its not the intent at all, i'm trying to grasp at and understand how this all weaves together, and it seems like while some of the old article postings have cited a firm stance between Eclipes group and the FSF, the open source community itself, close to the language, still has a non-concrete answer

and I'm not sure it's even a comparable question given that epl and gpl probably have different definitions of the words you're using

I just realized that the Google Groups thread you linked to includes my answers to these questions in some detail so I'm just kind of repeating myself.

So - ignoring the GPL compatibility issues - EPL is most comparative to the LGPL? Linking code is fine, and proprietary binary shipping without source available is also fine, but if you modify an included lib itself, that must be a shared modification?

they are both weak copyleft licenses, so similar in that regard

but they differ in their obligations and probably other details like patent protection

the GPL website has an approximately 200pg faqs page that might help here

LGPL is more restrictive than EPL in terms of usage of code released under those licenses.

I guess I'd turn this around and ask: do you have a specific use case regarding code or an application you're writing and distributing, where you need to understand what licenses you can use for that code/application, when working with Clojure? @m131

yes, about 20 or so github things I'm tinkering on / working with, and I choose AGPLv3 as my de-facto license on the majority of them

I'm fairly strongly "anti" GPL/LGPL precisely because of the difficulties they cause for anyone downstream trying to use them in conjunction with other software.

which, seems my license choice may be wrong/need to be reworked, or its impossible for anyone to use under my combination of language and my license choice - granted i'm only distributing my own created clj source code and no resultant dependencancies

I tend to choose ASL -- Apache Source License -- by default, unless I'm writing a Clojure library in which case I use EPL. I like both licenses.

I think AGPL / EPL are probably not compatible w/o some kind of exception like the classpath exception

which should work fine but is more complicated

Metabase is a Clojure project licensed AGPL with exceptions btw

maybe if that is good enough for metabase with 15,000+ github stars, its good enough for my tiny works then (I did see this commit earlier today: https://github.com/metabase/metabase/commit/666b1b453a71a1fca19e7b81739a58ce7fa45a14#diff-61e0bdf7e1b43c5c93d9488b22e04170)

>The idea of the GPL is that if you want to include our code in your program, your program must also be free software. It is supposed to put pressure on you to release your program in a way that makes it part of our community.

Just clarifying exactly what the difficulty is that's caused.

I default to GPLv2 for stuff that I want to stay in the open-source space and ad-hoc permissive/unpermissive licenses for other use cases.

So, technical question - I want to define a var in ns bar, while I am currently in ns foo - is the best way to just use in-ns? or some other means?

`

(defn proxy-def
           "Redefine a function with the wrapper around it. k = Symbol, v = Var to Fn."
           [[k v]]
           (eval
            `(def ~k ~(proxy-fn (deref v)))))

Why do you want to do that? (genuine question) It seems like a bad idea to me.

I want to implement something in the flavour of the robert-hooke package (ala, emacs lisp defadvice) for runtime tracing/storage of function inputs/outputs and input types + output types - https://github.com/ahungry/determinism (excuse the cheesy name)

if you peek at the readme, the intent is that I would have an sqlite database that I could then augment an IDE with

Take a look at how instrument in Spec is defined.

so i hover on function foo - it shows me the last N inputs/outputs it received at runtime on dev server etc

(as I suspected, Spec uses alter-var-root to replace an existing definition with a new version)

No need for eval etc.

thanks! I will give that a shot

this is an interesting one

what is the reason for this evaluation result?

`

(def my-dataset (atom {}))

         (defn fetch-data!                                                                                                                                               
           "Simulate a slow data condition and return back the number given,                                                                                             
           with the side effect of keeping a running sequence of n / sum."                                                                                               
           [n]                                                                                                                                                           
           (Thread/sleep 1e2)                                                                                                                                            
           (swap! my-dataset (fn [m] (conj m {(keyword (str n)) (+ n (reduce + (vals m)))}))))

         (defn get-data []                                                                                                                                               
           (reset! my-dataset {})                                                                                                                                        
           (dorun (pmap fetch-data! (range 6)))                                                                                                                          
           @my-dataset)

         ;; With pmap, this is produced?                                                                                                                                 
         (time (get-data))
         "Elapsed time: 100.93236 msecs"
         {:0 0, :1 25, :2 13, :3 7, :4 4, :5 54}

without pmap, using normal map, it would calculate as expected - the max value being 31 in the 5 slot: {:0 0, :1 1, :2 3, :3 7, :4 15, :5 31}

i could understand if the sums were in the wrong slot due to pmap chunking out the data, or if they were coming in at a lower total than expected due to the function application in the swap lexically scoping things oddly - but how is it getting up to 54?

While swap! itself is atomic, how does vals work?

its supposed to just pull the vals off a map, so {:x 1 :y 2} would result in [1 2] (or maybe (1 2))

That’s not what I mean

could a map exist in a state where it has a key but no val?

Which would give you lower results, not higher 🙂

yea...which is why I am very confused how it would get to 54

No, this makes sense

First 0 was processed

0 -> 0

Then 4 was processed

4 -> 4

Then 3 was processed

3 -> 7 (3 + 4 + 0)

Then 2 was processed

2 -> 13 (2 + 7 + 4 + 0)

Then 1 was processed

1 -> 25 (1 + 13 + 7 + 4 + 0)

Finally 5

So this makes perfect sense.

Put a watch on the atom and you'll see what it is swapped from to every step

@hiredman - yeah, good call

thanks all

Has anyone used tap> in tests? Is it a good or bad fit for detecting actions taking place during integration tests?

you mean leaving tap> in production code to use it for tests?

I'd say tap> is like debugging prints, but with values instead of strings, so it should not be in production code. Why not use with-redefs to get a peek into implementation?

I see experimenting with using it as a mock, where I might previously have used something like core async channels in my mock

Please help, why would (prn {:till-date #date "2019-01-01"}) fail with No reader function for tag date. no reading is happening env: (emacs + cider)

#inst "2019-01-01"

not sure where #date comes from

reading is happening when you send this form to repl

> not sure where #date comes from #date is custom tag

You need a custom reader for your custom tag

@kirill.salykin you can create a tagged-literal object

@kirill.salykin https://clojuredocs.org/clojure.core/tagged-literal

are there any plans for hygienic macros in clojure?

with the use of syntax quote resolution and gensym, it's not really an issue in Clojure?

as long as i remember to # all the things

if you don't you will usually get an error

well due to autoresolution, clojure will resolve the things you forgot and usually cause an error

user=> (defmacro foo [x] `(let [y 1] ~x))
#'user/foo
user=> (let [y 2] (foo y))
Syntax error macroexpanding clojure.core/let at (REPL:1:12).
user/y - failed: simple-symbol? at: [:bindings :form :local-symbol] spec: :clojure.core.specs.alpha/local-name
user/y - failed: vector? at: [:bindings :form :seq-destructure] spec: :clojure.core.specs.alpha/seq-binding-form
user/y - failed: map? at: [:bindings :form :map-destructure] spec: :clojure.core.specs.alpha/map-bindings
user/y - failed: map? at: [:bindings :form :map-destructure] spec: :clojure.core.specs.alpha/map-special-binding
user=>

i would've sworn i broke something like that once but i can't seem to find what it was

guess i'm just misremembering things.

that spec error looks pretty scary though haha

so basically there are facilities that guide you towards hygenic macros, but they aren't as strong as say racket's, and are easier to ignore, but that makes the macro system much simpler to implement and understand

just bought my clojure conj ticket, nearly forgot so I thought i'd throw a reminder up here 🎗️

I’m working on a library, and borrowing a txt definition file from a python lib that is inspiring mine. I realized I don’t actually know where the best/idiomatic place to stick these kind of things is… under /resources? Under /src/my/ns-prefix/? I’m using tools.deps and haven’t really needed to produce a jar.

the file in question gets read at startup and defines a registry of dimension units

so let’s assume that it gets slurped & parsed or such when my downstream project starts up, which I presume means directly relying on a filepath wouldn’t be a very hot plan.

Afternoon! Does anyone have any recommendations RE: Clojure libraries that they feel are good examples of using protocols?

clj-time imo

I followed that lib for some good examples of using protocols

https://github.com/clj-time/clj-time/blob/master/src/clj_time/core.clj

clj-time is deprecated. Please don't use it. Use Java Time directly or one of the wrapper libraries if you must.

@tkjone Feel free to look at seancorfield/next.jdbc as an example of a protocol-heavy library https://github.com/seancorfield/next-jdbc