Re: ExceptionInInitialization error

[Punit Naik]

Nice explanation.

On Thursday, February 25, 2016 at 8:46:46 PM UTC+5:30, Gary Verhaegen wrote:
>
> The lein deps :tree message (on stderr, which may be why it was not 
> included in your mail?) said:
>
>
> Possibly confusing dependencies found:
> [cheshire "5.3.1"]
>  overrides
> [riemann "0.2.10"] -> [clj-http "1.1.2" :exclusions
> [org.clojure/tools.reader]] -> [chesh
> ire "5.4.0" :exclusions [org.clojure/clojure]]
>  and
> [riemann "0.2.10"] -> [cheshire "5.5.0"]
>
> Which means: "In your project.clj file, you explicitly tell me that you 
> want cheshire 5.3.1, but you also tell me that you want riemann 0.2.10. It 
> turns out that riemann tells me it wants clj-http 1.1.2, which itself wants 
> cheshire 5.4.0. In addition, riemann also tells me that it wants cheshire 
> 5.5.0. Now, you're the boss, and I can't load multiple versions of the same 
> library, so I'm going to guess that you really want cheshire 5.3.1 and not 
> one of the other ones, though I must say I am a bit confused.
>
> I'm also a bit shy, so if this is really what you want, could you please 
> tell riemann that you do not want him to give me orders regarding the 
> version of cheshire to be included? That would make things less confusing."
>
> so you have to choose: either follow Leiningen's advice and tell riemann 
> to shut up, or decide that you don't actually need to insist on that 
> specific version of cheshire and give riemann what it needs.
>
> What Leiningen suggests (putting in exclusions) is a way of making 
> explicit the choices that he is already guessing from your project.clj, so 
> in this case it does not help.
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: ANN: Specter 0.11.0, performance without the tradeoffs

[Mark Engelberg]

I'm glad it helped!

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: ANN: Specter 0.11.0, performance without the tradeoffs

[Nathan Marz]

Great idea on interning a var at macro-time and then using it later! I did 
something similar for the ClojureScript implementation of inline caching 
but for some odd reason didn't think of doing it for the Clojure version. 
I'm seeing a big performance improvement for the [:a :b :c] benchmark from 
my post - about 15% faster than before and now very close to full manual 
precompilation.

Here's the 
commit: 
https://github.com/nathanmarz/specter/commit/fbca7ab99c84d93a28f7773f1c56be12e1a939a3


On Tuesday, May 31, 2016 at 9:33:29 PM UTC-4, puzzler wrote:
>
> I think this is an interesting problem, so here are some additional 
> brainstorms on the issue that may or may not be useful...
>
> One strategy to create a global mutable variable from inside the function 
> would be to use def at macroexpansion time to create a var, and then just 
> refer to it in the expansion, like this:
>
> (defmacro expand-to-something-with-mutable-global []
>   ; At macroexpansion time, create a (private) var containing a volatile.
>   (let [global-name (gensym "cache")]
> (eval `(def ^:private ~global-name (volatile! nil)))
> ; Now macro can refer to this var, can use as a cache, etc.
> `(if-let [cache-contents# (deref ~global-name)] 
>(do-something-with cache-contents#)
>(reset! ~global-name init-value-for-cache
>
> Not sure if this would be any faster than ConcurrentHashMap, but I would 
> guess that it would be if Clojure resolves the location of the var in 
> memory once, at compile-time.
>
> A related technique would be for Specter to maintain an ArrayList of 
> volatiles.  At macroexpansion time, you add a fresh volatile to the end of 
> the ArrayList, noting the index of its location, and then inside the macro 
> you hardcode a lookup in the ArrayList at the specific index to retrieve 
> the volatile containing the cache for this particular expansion.  I would 
> expect this to be faster than looking up in a hash map, although there'd be 
> some additional concurrency/locking details to worry about that I assume 
> ConcurrentHashMap handles for you.
>
> Or just use an ArrayList's slot directly as the cache (rather than storing 
> a volatile to add a level of indirection), but then the concurrency 
> logistics would be even more complicated.
>
> On Tue, May 31, 2016 at 12:50 PM, Nathan Marz  > wrote:
>
>> No, because that global mutable variable would need to be specifiable by 
>> Specter on usage of the library. For example, if you wrote:
>>
>> (defn foo []
>>   (select [:a :b] {:a {:b 1}}))
>>
>> `select` has no ability to control anything outside the context of its 
>> form. It certainly can't wrap `foo` to put a volatile field in its closure. 
>> So for the static-field idea, it would expand to something like:
>>
>> (defn foo []
>>   (static-field [pathcache]
>>  (if-not pathcache (set! pathcache ...))
>>  ...
>>  ))
>>
>>
>>
>> On Tuesday, May 31, 2016 at 3:15:26 PM UTC-4, puzzler wrote:
>>>
>>> In your writeup, you say that there would be further speed benefits if 
>>> you could have a global mutable variable within the context of a function 
>>> (like a static field).
>>>
>>> Can't you effectively accomplish that already in Clojure like this?:
>>>
>>> (let [mycache (volatile! nil)]
>>>   (defn foo []
>>>   ...)))
>>>
>> -- 
>> You received this message because you are subscribed to the Google
>> Groups "Clojure" group.
>> To post to this group, send email to clo...@googlegroups.com 
>> 
>> Note that posts from new members are moderated - please be patient with 
>> your first post.
>> To unsubscribe from this group, send email to
>> clojure+u...@googlegroups.com 
>> For more options, visit this group at
>> http://groups.google.com/group/clojure?hl=en
>> --- 
>> You received this message because you are subscribed to the Google Groups 
>> "Clojure" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to clojure+u...@googlegroups.com .
>> For more options, visit https://groups.google.com/d/optout.
>>
>
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: ANN: Specter 0.11.0, performance without the tradeoffs

[Mark Engelberg]

I think this is an interesting problem, so here are some additional
brainstorms on the issue that may or may not be useful...

One strategy to create a global mutable variable from inside the function
would be to use def at macroexpansion time to create a var, and then just
refer to it in the expansion, like this:

(defmacro expand-to-something-with-mutable-global []
  ; At macroexpansion time, create a (private) var containing a volatile.
  (let [global-name (gensym "cache")]
(eval `(def ^:private ~global-name (volatile! nil)))
; Now macro can refer to this var, can use as a cache, etc.
`(if-let [cache-contents# (deref ~global-name)]
   (do-something-with cache-contents#)
   (reset! ~global-name init-value-for-cache

Not sure if this would be any faster than ConcurrentHashMap, but I would
guess that it would be if Clojure resolves the location of the var in
memory once, at compile-time.

A related technique would be for Specter to maintain an ArrayList of
volatiles.  At macroexpansion time, you add a fresh volatile to the end of
the ArrayList, noting the index of its location, and then inside the macro
you hardcode a lookup in the ArrayList at the specific index to retrieve
the volatile containing the cache for this particular expansion.  I would
expect this to be faster than looking up in a hash map, although there'd be
some additional concurrency/locking details to worry about that I assume
ConcurrentHashMap handles for you.

Or just use an ArrayList's slot directly as the cache (rather than storing
a volatile to add a level of indirection), but then the concurrency
logistics would be even more complicated.

On Tue, May 31, 2016 at 12:50 PM, Nathan Marz  wrote:

> No, because that global mutable variable would need to be specifiable by
> Specter on usage of the library. For example, if you wrote:
>
> (defn foo []
>   (select [:a :b] {:a {:b 1}}))
>
> `select` has no ability to control anything outside the context of its
> form. It certainly can't wrap `foo` to put a volatile field in its closure.
> So for the static-field idea, it would expand to something like:
>
> (defn foo []
>   (static-field [pathcache]
>  (if-not pathcache (set! pathcache ...))
>  ...
>  ))
>
>
>
> On Tuesday, May 31, 2016 at 3:15:26 PM UTC-4, puzzler wrote:
>>
>> In your writeup, you say that there would be further speed benefits if
>> you could have a global mutable variable within the context of a function
>> (like a static field).
>>
>> Can't you effectively accomplish that already in Clojure like this?:
>>
>> (let [mycache (volatile! nil)]
>>   (defn foo []
>>   ...)))
>>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: IoT: Clojurescript -> Jerryscript?

[Paul deGrandis]

Hi Gregg,

I've previously used ClojureScript to target other JavaScript engines (on 
small devices and on Android), without any issue.  You shouldn't need to do 
anything special, but if something comes up and you hit a snag, just post 
here.

Good luck and have fun!

Cheers,
Paul

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Making my own functions visible to the clojurescript.io REPL

['Lee' via Clojure]

Thanks Andrea.

I think I wasn't clear. I'm already hosting it on my own server. But I'm 
starting with a copy of the cljs-repl-web-devel project and I don't know 
where to put my code to make it callable in the REPL.

I'll take it to slack, as you suggest.

Thanks,

 -Lee

On Tuesday, May 31, 2016 at 5:46:53 PM UTC-4, Andrea Richiardi wrote:
>
> Hello Lee, thanks for using clojurescript.io first of all.
> At the moment what you try to accomplish is not possible unfortunately. It 
> would mean to host arbitrary code on out servers. I was thinking about a 
> simple collaborative platform so that you and someone else could share the 
> "current state" of the Repl buy we have not started the project yet.
> This would mean basically to add a websocket to the current site + user 
> login.
> Definitely doable.
>
> What you can do is to reuse our components, and in particular 
> https://github.com/Lambda-X/replumb and 
> https://github.com/Lambda-X/re-console and host your app somewhere.
>
> Feel free to ping me or Tomek on Slack if you have questions ok?
>
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Making my own functions visible to the clojurescript.io REPL

[Andrea Richiardi]

On Tuesday, May 31, 2016 at 1:51:19 PM UTC-7, Lee wrote:
...
> Thanks,
> 
> -Lee

Sorry for the typos I was on mobile.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Making my own functions visible to the clojurescript.io REPL

[Andrea Richiardi]

Hello Lee, thanks for using clojurescript.io first of all.
At the moment what you try to accomplish is not possible unfortunately. It 
would mean to host arbitrary code on out servers. I was thinking about a simple 
collaborative platform so that you and someone else could share the "current 
state" of the Repl buy we have not started the project yet.
This would mean basically to add a websocket to the current site + user login.
Definitely doable.

What you can do is to reuse our components, and in particular 
https://github.com/Lambda-X/replumb and https://github.com/Lambda-X/re-console 
and host your app somewhere.

Feel free to ping me or Tomek on Slack if you have questions ok?

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: IoT: Clojurescript -> Jerryscript?

[Gregg Reynolds]

Hi Christopher,

Thanks for the feedback.  If things go approximately as planned I'll be
hacking at this over the next few weeks. You'll be hearing g from me.

thanks!

gregg
On May 27, 2016 5:15 PM, "Christopher Small"  wrote:

> I imagine this should be possible, as long as JerryScript isn't missing
> any features needed by the js code the cljs compiles to. I'd bet most code
> would be fine, as long as it doesn't depend on OS features. So I would Just
> Try It with a simple hello world app and see how complicated you can get
> from there.
>
> I started a project that was trying to provide a microcontroller computing
> API abstracting over the subtle differences between different targets
> (BeagleBone, Pi, and Arduino over Firmata). The biggest issue with this is
> that JVM Clojure is a sluggard to boot, and for some microcontroller units
> too memory-hungry. And of course having to use Firmata with Arduino is a
> major restriction. In talking with others about this, I thought that
> targeting node would be a perfect solution for BeagleBone or Pi, but being
> able to directly target Arduino (w/o Firmata) would be awesome :-)
>
> I haven't had any time for this project with other open source things on
> my plate, but I'd be happy to provide guidance if you're interested in
> working on implementations of this API targeted at Jerryscript.
>
> https://github.com/clj-bots/pin-ctrl
>
> Cheers :-)
>
> Chris
>
>
>
>
> On Friday, May 27, 2016 at 9:33:17 AM UTC-7, Gregg Reynolds wrote:
>>
>> Hi folks,
>>
>> I just came across http://samsung.github.io/jerryscript/ , which Samsung
>> apparently open-sourced last fall.  Jerryscript is a bit of a misnomer, its
>> not a language but a JS engine designed for IoT devices.  Sorta like
>> node.js only smaller, I guess.
>>
>> Seems to run on Zephyr on Arduino101
>> ,
>> believe it or not.
>>
>> If we can run JS on constrained IoT devices, then we ought to be able to
>> write the code in Clojurescript, no?
>>
>> Anybody have any further info on this?  I'm going to be looking at the
>> Clojurescript source this weekend to try to get an idea of how hard it
>> would be to target Jerryscript (or iot.js, which is a companion thing).
>> Any advice/help would be appreciated.
>>
>> Thanks,
>>
>> Gregg
>>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Making my own functions visible to the clojurescript.io REPL

['Lee' via Clojure]

I'm trying to hack a copy of the http://clojurescript.io REPL so that I can 
use it to allow people to run some of my code in a REPL in a web page.

But I can't figure out where to put my functions in the cljs-repl-web-devel 
project so that the user can call them in the REPL. 

The REPL is in the cljs.user namespace and I tried to figure out how to add 
my functions to that, but didn't succeed (in part because there's no in-ns 
in Clojurescript, and because I don't think the code that defines the 
namespace is in the project). Then I tried to figure out how to make 
another namespace also visible from the REPL, but failed there too.

Any pointers?

Thanks,

-Lee

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: ANN: Specter 0.11.0, performance without the tradeoffs

[Nathan Marz]

No, because that global mutable variable would need to be specifiable by 
Specter on usage of the library. For example, if you wrote:

(defn foo []
  (select [:a :b] {:a {:b 1}}))

`select` has no ability to control anything outside the context of its 
form. It certainly can't wrap `foo` to put a volatile field in its closure. 
So for the static-field idea, it would expand to something like:

(defn foo []
  (static-field [pathcache]
 (if-not pathcache (set! pathcache ...))
 ...
 ))



On Tuesday, May 31, 2016 at 3:15:26 PM UTC-4, puzzler wrote:
>
> In your writeup, you say that there would be further speed benefits if you 
> could have a global mutable variable within the context of a function (like 
> a static field).
>
> Can't you effectively accomplish that already in Clojure like this?:
>
> (let [mycache (volatile! nil)]
>   (defn foo []
>   ...)))
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: ANN: Specter 0.11.0, performance without the tradeoffs

[Mark Engelberg]

In your writeup, you say that there would be further speed benefits if you
could have a global mutable variable within the context of a function (like
a static field).

Can't you effectively accomplish that already in Clojure like this?:

(let [mycache (volatile! nil)]
  (defn foo []
  ...)))

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Is there an apply-able new?

[Kenneth Tilton]

It woiks!

This game never gets old. I am going to be unreasonably happy for the rest
of the day.

For noobs like me that stumble across this...

1. I added a script element to my index.html:

  
> var MyTerop = {};
> MyTerop.make = function(cls) {
> return new (Function.prototype.bind.apply(cls, arguments));
> };
>   
>

2. Leveraging a function I have that translates isomorphically from cljs
types to qooxdoo types:

(apply MyTerop/make
>
>(qxia-type-to-qx-class type)
>
>["It Woiks!", "identica/mmedia/games.png"])
>
>
[This is temporarily in the spot normally dedicated to the Button type,
whose constructor takes optional args for the label and an icon reference,
which will soon -- well, more below.]

3. Put the tools in the truck. Well, one more minor thing: can these be
suppressed?

WARNING: No such namespace: MyTerop, could not locate MyTerop.cljs,
>> MyTerop.cljc, or Closure namespace "" at line 81
>> src/tiltontec/qxia/base.cljs
>
> WARNING: Use of undeclared Var MyTerop/make at line 81
>> src/tiltontec/qxia/base.cljs
>
>
I tried this in externs.js to no avail:

MyTerop = {};
>
> MyTerop.make = function () {};
>
>
This is way cool because we are getting close to the point where a Qxia
user can just look at the excellent qx.Mobile doc and code up a qxia/make
call:

   :qx-class -- the actual qooxdoo class name
   :constructor-args -- as above
   ...and then any properties they see in the qooxdoo doc for that class.
The qx.Class API lets me ask the properties so I can cull the initargs
meant for qooxdoo and bundle them up in a map and set them all in one go.
Other purely application properties get left behind automatically (not that
I think they would bother qx, but still.)

In the Common Lisp version I whittled away at their very big library
piecemeal supporting classes/properties as I needed them, which would not
make a very attractive library for general use.

Ya gotta love dynamic.

Thanks again.

-kt


On Tue, May 31, 2016 at 8:28 AM, hiskennyness  wrote:

>
>
> On Friday, May 27, 2016 at 10:57:05 PM UTC-4, Brandon Bloom wrote:
>>
>> The new operation intentionally demands a statically knowable type to
>> construct. While this is true of Java as well, it's not true of JavaScript.
>> However, it is true of the Google Closure compiler's "type system" for
>> advanced compilation. That said, if the library you're using isn't going to
>> be optimized with advanced, you can do any typical dynamic metaprogramming
>> you'd want to do in JavaScript and call in to that.
>>
>> mynamespace.make = function(cls) {
>>   return new (Function.prototype.bind.apply(cls, arguments));
>> };
>>
>> Then from ClojureScript:
>>
>> (apply mynamespace/make qx.ui.mobile.form.Button ["Go!"])
>>
>>
> Looking at this for the third time I am not sure what held me back the
> first two times.
>
> Thx, I'll give it a shot. This keeps coming up where qooxdoo decides some
> things should be constructor params instead of properties.
>
>  -kt
>
>
>>
>> On Friday, May 27, 2016 at 10:24:12 AM UTC-7, hiskennyness wrote:
>>>
>>> qooxdoo lets us supply oft-used widget parameters to the constructor.
>>> For example, a button can specify its label and icon at new time. And this
>>> works fine from cljs:
>>>
>>>(new qx.ui.mobile.form.Button "Go!") ;; label is the first arg
>>>
>>> But I am wrapping qooxdoo in something more concise and want to be able
>>> to code:
>>>
>>>(qxia/make (::Button "Go!")
>>>   ..other init params to be "set"
>>>
>>> Unfortunately I cannot even
>>>
>>>(new (qx-class qia-type)) ;; computed class
>>>
>>> Let alone
>>>
>>>(apply new (qx-class qxia-type) make-inits)
>>>
>>> Not that I thought I would get away with it. :) I grok new is special.
>>>
>>> I can fall back on the qooxdoo API and use setLabel and setIcon, but I
>>> like learning so I thought I would ask if there were some way to:
>>>
>>>1. compute a class (preferably by first constructing a name) and/or
>>>2. do the moral equivalent of applying new to parameters
>>>
>>> -hk
>>>
>>> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to a topic in the
> Google Groups "Clojure" group.
> To unsubscribe from this topic, visit
> https://groups.google.com/d/topic/clojure/4HWF7725JvM/unsubscribe.
> To unsubscribe from this group and all its topics, send an email to
> clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>



-- 
Kenneth Tilton
54 Isle of Venice Dr, Apt 5
Fort Lauderdale, FL 33301

kentil...@gmail.com
64

Re: clojure.spec generation question

[Rich Hickey]

You are not labeling your preds, so ::not-predicate is taken as the label for 
::and-predicate etc.

Also, tuples are not labeled:

(require '[clojure.spec :as s])
(require '[clojure.spec.gen :as gen])

(s/def ::atom string?)

(s/def ::predicate (s/or
   :not ::not-predicate
   :and ::and-predicate
   :or ::or-predicate
   :atom ::atom))

(s/def ::and-predicate (s/cat :pred #{:and} :args (s/+ ::predicate)))
(s/def ::or-predicate  (s/cat :pred #{:or} :args (s/+ ::predicate)))
(s/def ::not-predicate (s/tuple #{:not} ::predicate))

user=> (prn (take 5 (gen/sample (s/gen ::predicate
([:not [:not (:or "")]] "L" [:not (:and (:and (:and "" (:or "tQ" "s" ""))) 
[:not [:not "T"]])] "19f" [:not "8lC”])

spec works the same under the hood as what Gary showed, e.g. s/or turns into 
gen/one-of etc.

Rich

> On May 31, 2016, at 11:32 AM, Jeroen van Dijk  
> wrote:
> 
> Hi Gary,
> 
> Thanks for the feedback. I've tried it with test.check itself and I get 
> better results (see below). So I'm guessing clojure.spec needs different 
> input or it works differently underneath.
> 
> Thanks,
> Jeroen
> 
> (require '[clojure.test.check :as tc])
> (require '[clojure.test.check.generators :as gen])
> (require '[clojure.test.check.properties :as prop])
> 
> (def gen-atom (gen/elements (mapcat (juxt (partial str "f_a")
>  (partial str "t_a")) (range 10
> 
> (def gen-atom (gen/elements (mapcat (juxt (partial str "f_a")
>  (partial str "t_a")) (range 10
> 
> (defn gen-cat
>  "Returns a generator of a sequence catenated from results of
> gens, each of which should generate something sequential."
>  [& gens]
>  (gen/fmap #(vec (apply concat %))
>(apply gen/tuple gens)))
> 
> (def compound (fn [inner-gen]
>(gen/one-of [(gen-cat (gen/elements [[:not]]) (gen/tuple 
> inner-gen))
> (gen-cat (gen/elements [[:or]])  (gen/tuple 
> inner-gen)  (gen/not-empty (gen/list inner-gen)))
> (gen-cat (gen/elements [[:and]]) (gen/tuple 
> inner-gen) (gen/not-empty (gen/list inner-gen)))])))
> (def gen-predicate (gen/recursive-gen compound gen-atom))
> 
> ([:or [:and [:or "t_a3" "f_a5"] [:and "t_a5" "t_a6"]] [:or [:not "t_a5"] 
> [:not "t_a1"]]] [:and [:and [:and "f_a4" "f_a4" "f_a9"] [:or "f_a2" "t_a5"]] 
> [:and [:not "f_a3"] [:not "f_a1"]]] [:or "t_a5" "f_a6" "t_a7" "t_a3"] [:not 
> [:and [:and [:not [:not "t_a5"]] [:and [:or "t_a4" "f_a7"] [:not "t_a2"] 
> [:not "f_a6"] [:and "t_a5" "t_a4"] [:or "t_a8" "f_a0"]] [:not [:or "f_a8" 
> "f_a2"]]] [:or [:or [:not "f_a0"] [:or "t_a9" "t_a7"]] [:not [:or "t_a5" 
> "f_a6" "f_a1"]]] [:not [:and [:and "t_a0" "t_a3"] [:or "f_a2" "t_a5"] 
> [:or [:not [:and [:or [:not "f_a1"] [:and "f_a0" "t_a8"]] [:not [:not 
> "t_a7"]] [:or [:or "f_a1" "f_a8" "f_a7"] [:and "f_a9" "t_a2" [:not [:or 
> [:or [:not "t_a7"] [:not "t_a8"]] [:or [:and "t_a3" "t_a0"] [:not "t_a6" 
> [:not [:and [:and [:and "f_a9" "t_a7"] [:and "f_a6" "f_a9"] [:or "f_a9" 
> "t_a0" "t_a8"]] [:and [:not "f_a4"] [:or "t_a3" "f_a4"] [:or "t_a3" 
> "f_a3"])
> 
> On Tue, May 31, 2016 at 3:14 AM, Gary Fredericks  
> wrote:
> At a glance, this is probably the normal increasing-size behavior of 
> test.check, and the bias should only be present for the first few samples. 
> E.g., if you do a (take 1000 (gen/sample ...)), it should be more uniform.
> 
> Whether it's a real problem depends on how you're running your tests. I 
> haven't yet looked into whether clojure.spec provides some default way of 
> running test.check properties, so I'm not sure about that. But as long as 
> you're running "enough" tests, e.g. >100, it should be fine.
> 
> 
> On Monday, May 30, 2016 at 4:05:52 PM UTC-5, Jeroen van Dijk wrote:
> I'm trying to generate logical predicates in order to test a function that 
> should return the predicate in DNF. The generation seems to be biased towards 
> one of the predicates. What am I doing wrong?
> 
> (require '[clojure.spec :as s])
> (require '[clojure.spec.gen :as gen])
> 
> (s/def ::atom string?)
> 
> (s/def ::predicate (s/or
>::not-predicate
>::and-predicate
>::or-predicate
>::atom))
> 
> (s/def ::and-predicate (s/cat :pred #{:and} :args (s/+ ::predicate)))
> (s/def ::or-predicate  (s/cat :pred #{:or} :args (s/+ ::predicate)))
> (s/def ::not-predicate (s/tuple :pred #{:not} ::predicate))
> 
> (prn (take 5 (gen/sample (s/gen ::predicate
> ;;=> 
> ((:and (:and "")) "" "X" "G" (:and "yd" (:and "c" "" (:and "F" (:and "" "8" 
> "Hb" "U0d")) "C") (:and (:and "1" "e" (:and "ME01" "w" "Y4" "" "P4") "J4m4" 
> "8") "Q7c" "") (:and (:and (:and "" "dG"))) "gw5"))
> 
> 
> No :or's or :not's here. If I change the order of s/or above the bias 
> changes. What's a better approach?
> 
> Thanks,
> Jeroen
> 
> 
> -- 
> You receiv

[ANN] Clojure 1.9.0-alpha4

[Stuart Halloway]

Clojure 1.9.0-alpha4 is now available.

Try it via

- Download: https://repo1.maven.org/maven3/org/clojure/clojure/1.9.0-alpha4
- Leiningen: [org.clojure/clojure "1.9.0-alpha4"]

1.9.0-alpha4 includes the following changes since 1.9.0-alpha3:

- fix describe empty cat
- improve update-in perf
- optimize seq (&) destructuring

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: clojure.spec generation question

[Jeroen van Dijk]

Hi Gary,

Thanks for the feedback. I've tried it with test.check itself and I get
better results (see below). So I'm guessing clojure.spec needs different
input or it works differently underneath.

Thanks,
Jeroen

(require '[clojure.test.check :as tc])
(require '[clojure.test.check.generators :as gen])
(require '[clojure.test.check.properties :as prop])

(def gen-atom (gen/elements (mapcat (juxt (partial str "f_a")
  (partial str "t_a")) (range 10

(def gen-atom (gen/elements (mapcat (juxt (partial str "f_a")
  (partial str "t_a")) (range 10

(defn gen-cat
  "Returns a generator of a sequence catenated from results of
gens, each of which should generate something sequential."
  [& gens]
  (gen/fmap #(vec (apply concat %))
(apply gen/tuple gens)))

(def compound (fn [inner-gen]
(gen/one-of [(gen-cat (gen/elements [[:not]]) (gen/tuple
inner-gen))
 (gen-cat (gen/elements [[:or]])  (gen/tuple
inner-gen)  (gen/not-empty (gen/list inner-gen)))
 (gen-cat (gen/elements [[:and]]) (gen/tuple
inner-gen) (gen/not-empty (gen/list inner-gen)))])))
(def gen-predicate (gen/recursive-gen compound gen-atom))

([:or [:and [:or "t_a3" "f_a5"] [:and "t_a5" "t_a6"]] [:or [:not "t_a5"]
[:not "t_a1"]]] [:and [:and [:and "f_a4" "f_a4" "f_a9"] [:or "f_a2"
"t_a5"]] [:and [:not "f_a3"] [:not "f_a1"]]] [:or "t_a5" "f_a6" "t_a7"
"t_a3"] [:not [:and [:and [:not [:not "t_a5"]] [:and [:or "t_a4" "f_a7"]
[:not "t_a2"] [:not "f_a6"] [:and "t_a5" "t_a4"] [:or "t_a8" "f_a0"]] [:not
[:or "f_a8" "f_a2"]]] [:or [:or [:not "f_a0"] [:or "t_a9" "t_a7"]] [:not
[:or "t_a5" "f_a6" "f_a1"]]] [:not [:and [:and "t_a0" "t_a3"] [:or "f_a2"
"t_a5"] [:or [:not [:and [:or [:not "f_a1"] [:and "f_a0" "t_a8"]] [:not
[:not "t_a7"]] [:or [:or "f_a1" "f_a8" "f_a7"] [:and "f_a9" "t_a2"
[:not [:or [:or [:not "t_a7"] [:not "t_a8"]] [:or [:and "t_a3" "t_a0"]
[:not "t_a6" [:not [:and [:and [:and "f_a9" "t_a7"] [:and "f_a6"
"f_a9"] [:or "f_a9" "t_a0" "t_a8"]] [:and [:not "f_a4"] [:or "t_a3" "f_a4"]
[:or "t_a3" "f_a3"])

On Tue, May 31, 2016 at 3:14 AM, Gary Fredericks 
wrote:

> At a glance, this is probably the normal increasing-size behavior of
> test.check, and the bias should only be present for the first few samples.
> E.g., if you do a (take 1000 (gen/sample ...)), it should be more uniform.
>
> Whether it's a real problem depends on how you're running your tests. I
> haven't yet looked into whether clojure.spec provides some default way of
> running test.check properties, so I'm not sure about that. But as long as
> you're running "enough" tests, e.g. >100, it should be fine.
>
>
> On Monday, May 30, 2016 at 4:05:52 PM UTC-5, Jeroen van Dijk wrote:
>>
>> I'm trying to generate logical predicates in order to test a function
>> that should return the predicate in DNF. The generation seems to be biased
>> towards one of the predicates. What am I doing wrong?
>>
>> (require '[clojure.spec :as s])
>> (require '[clojure.spec.gen :as gen])
>>
>> (s/def ::atom string?)
>>
>> (s/def ::predicate (s/or
>> ::not-predicate
>> ::and-predicate
>> ::or-predicate
>> ::atom))
>>
>> (s/def ::and-predicate (s/cat :pred #{:and} :args (s/+ ::predicate)))
>> (s/def ::or-predicate  (s/cat :pred #{:or} :args (s/+ ::predicate)))
>> (s/def ::not-predicate (s/tuple :pred #{:not} ::predicate))
>>
>> (prn (take 5 (gen/sample (s/gen ::predicate
>> ;;=>
>> ((:and (:and "")) "" "X" "G" (:and "yd" (:and "c" "" (:and "F" (:and ""
>> "8" "Hb" "U0d")) "C") (:and (:and "1" "e" (:and "ME01" "w" "Y4" "" "P4")
>> "J4m4" "8") "Q7c" "") (:and (:and (:and "" "dG"))) "gw5"))
>>
>>
>> No :or's or :not's here. If I change the order of s/or above the bias
>> changes. What's a better approach?
>>
>> Thanks,
>> Jeroen
>>
>> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.

Re: set return value is unordered, is that a bug or by design?

[James Reeves]

Sets are unordered data structures, so it's by design.

- James

On 31 May 2016 at 13:54,  wrote:

> I would expect the returned set to be
>
> #{1 2 3} but i get the following. Copied from repl
>
>
> user=> (set [1 1 2 2 3 3])
>
> #{1 3 2}
>
>
> user=> (set '(1 1 2 3 2 4 5 5))
>
> #{1 4 3 2 5}
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: set return value is unordered, is that a bug or by design?

[Alan Thompson]

sets & maps make no guarantee about the order of their entries. In fact,
they deliberately use hash functions to keep simple keys like 1,2,3 "spread
out" in their hash-codes. This causes the "random" ordering when printed.
If you want a set to print in order (often worth the trouble, I think), use
"sorted-set":

user=> (def s1 (set [1 2 3]))
#'user/s1
user=> s1
#{1 3 2}
user=> (def s2 (into (sorted-set) s1))
#'user/s2
user=> s2
#{1 2 3}


The same trick works for "sorted-map"

Alan


On Tue, May 31, 2016 at 8:12 AM, Alan Thompson  wrote:

> I believe you may have meant sorted-set
> 
>
> On Tue, May 31, 2016 at 6:10 AM, vandr0iy 
> wrote:
>
>> You could use sorted-map, if you wish to have them ordered:
>>
>> https://clojuredocs.org/clojure.core/sorted-map
>>
>> there is also sorted-map-by, which lets you define the
>> comparator based on which the values have to be sorted
>>
>> On 05/31/2016 02:54 PM, james.naad...@gmail.com wrote:
>>
>> I would expect the returned set to be
>>
>> #{1 2 3} but i get the following. Copied from repl
>>
>>
>> user=> (set [1 1 2 2 3 3])
>>
>> #{1 3 2}
>>
>>
>> user=> (set '(1 1 2 3 2 4 5 5))
>>
>> #{1 4 3 2 5}
>> --
>> You received this message because you are subscribed to the Google
>> Groups "Clojure" group.
>> To post to this group, send email to clojure@googlegroups.com
>> Note that posts from new members are moderated - please be patient with
>> your first post.
>> To unsubscribe from this group, send email to
>> clojure+unsubscr...@googlegroups.com
>> For more options, visit this group at
>> http://groups.google.com/group/clojure?hl=en
>> ---
>> You received this message because you are subscribed to the Google Groups
>> "Clojure" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to clojure+unsubscr...@googlegroups.com.
>> For more options, visit https://groups.google.com/d/optout.
>>
>>
>> --
>> You received this message because you are subscribed to the Google
>> Groups "Clojure" group.
>> To post to this group, send email to clojure@googlegroups.com
>> Note that posts from new members are moderated - please be patient with
>> your first post.
>> To unsubscribe from this group, send email to
>> clojure+unsubscr...@googlegroups.com
>> For more options, visit this group at
>> http://groups.google.com/group/clojure?hl=en
>> ---
>> You received this message because you are subscribed to the Google Groups
>> "Clojure" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to clojure+unsubscr...@googlegroups.com.
>> For more options, visit https://groups.google.com/d/optout.
>>
>
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: set return value is unordered, is that a bug or by design?

[Alan Thompson]

I believe you may have meant sorted-set


On Tue, May 31, 2016 at 6:10 AM, vandr0iy 
wrote:

> You could use sorted-map, if you wish to have them ordered:
>
> https://clojuredocs.org/clojure.core/sorted-map
>
> there is also sorted-map-by, which lets you define the
> comparator based on which the values have to be sorted
>
> On 05/31/2016 02:54 PM, james.naad...@gmail.com wrote:
>
> I would expect the returned set to be
>
> #{1 2 3} but i get the following. Copied from repl
>
>
> user=> (set [1 1 2 2 3 3])
>
> #{1 3 2}
>
>
> user=> (set '(1 1 2 3 2 4 5 5))
>
> #{1 4 3 2 5}
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Clojure with Tensorflow, Torch etc (call for participation, brainstorming etc)

[kovas boguta]

On Tue, May 31, 2016 at 9:36 AM, atucker  wrote:

> Given that the TensorFlow website invites people to build interfaces from
> other languages using SWIG, I guess they feel that access to the C++
> component is the major thing.  So while I agree with Christian about
> reinventing the wheel, it may be that to interface at that level would
> involve reinventing only a relatively few spokes.
>

I looked into this and unfortunately Tensorflow is not as language-agnostic
as it might seem.

If you just want predictions from a trained model, you can connect with
SWIG.

However, for training, it is required to use Python because Python installs
a bunch of backprop definitions into the graph. It should be possible to
pull this off (and then call into it from Clojure).

The difficulty of doing so is hard for me to assess, so I'm hoping someone
can chime in on this.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Clojure with Tensorflow, Torch etc (call for participation, brainstorming etc)

[kovas boguta]

On Tue, May 31, 2016 at 7:51 AM, Christian Weilbach <
whitesp...@polyc0l0r.net> wrote:

>
> Almost all of the development in deep learning is done in Python, so
> having to reproduce this work on a different runtime (and language)
> seems non-Clojure-like for me (compared to being hosted on the JVM and
> leveraging this ecosystem). deeplearning4j is already attempting it
> from the Java side with the argument of distributed scaling, but
> again, there is a ton of work done for the Python toolkits including
> massive scaling (e.g. with tensorflow) and most research is there, so
> my question would be what the actual goals for a Clojure stack would be?


Good question. Basic answer is that we are in the early stages of
discovering the right abstractions for these systems; Clojure provides a
strong platform for exploring the basic issues. The biggies for me are:

1. Model composition. Most of these systems have some flavor of
compilation, often with a heavy dose of mutability in the construction of
the graph. I'd argue its easier and simpler to explore the design space
starting from immutable data representations. Given the speed of evolution
in model architectures, this seems pretty important.

2. Introspection & interactivity. With Clojurescript (and even just
Clojure) we have excellent options for creating interactive UIs on top of
the models. Yes, theres IPython, but thats not a really equivalent to the
power provided by Clojurescipt.

Now, I'm all in favor of not reinventing the wheel, thats why I'm wondering
what the best available foundation would be. JyNI is quite interesting and
I hope it takes off. But just having a wrapper on a high-level Python lib
probably isn't worth the hassle, unless you get some fundamentally new
leverage.

Poking around I actually discovered something closer to what I want:
https://github.com/dmlc/mxnet

Its pretty much the only DL platform intended to be consumed as a library,
from any language. And there are already sensible JVM bindings to it.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

ANN: Specter 0.11.0, performance without the tradeoffs

[Nathan Marz]

Specter is a library for querying and transforming nested data structures 
concisely and efficiently. The 0.11.0 release is a huge milestone that 
implements something which for the better part of the past year I wasn't 
sure was possible. In summary: now you don't have to do anything special to 
make Specter run fast. The prior work of manually precompiling your paths 
for performance is now seamlessly automated.

As part of the release, wrote up a detailed guide to how Specter achieves 
its high performance. Should also be an interesting read for anyone curious 
about the design of a very powerful Clojure library. 
https://github.com/nathanmarz/specter/wiki/Specter-0.11.0:-Performance-without-the-tradeoffs

Note that there are some backwards incompatible changes in this release, so 
please read the changelog below. The core select/transform/etc. functions 
have changed to macros, and there have been some name updates to clean up 
the terminology. Updating your projects to the new changes should be very 
easy.



Changes:

* New `path` macro does intelligent inline caching of the provided path. 
The path is factored into a static portion and into params which may change 
on each usage of the path (e.g. local parameters). The static part is 
factored and compiled on the first run-through, and then re-used for all 
subsequent invocations. As an example, `[ALL (keypath k)]` is factored into 
`[ALL keypath]`, which is compiled and cached, and `[k]`, which is provided 
on each execution. If it is not possible to precompile the path (e.g. [ALL 
some-local-variable]), nothing is cached and the path will be compiled on 
each run-through.

* BREAKING CHANGE: all `select/transform/setval/replace-in` functions 
changed to macros and moved to com.rpl.specter.macros namespace. The new 
macros now automatically wrap the provided path in `path` to enable inline 
caching. Expect up to a 100x performance improvement without using explicit 
precompilation, and to be within 2% to 15% of the performance of explicitly 
precompiled usage.

* Added `select*/transform*/setval*/replace-in*/etc.` functions that have 
the same functionality as the old `select/transform/setval/replace-in` 
functions.

* Added `must-cache-paths!` function to throw an error if it is not 
possible to factor a path into a static portion and dynamic parameters.

* BREAKING CHANGE: `defpath` renamed to `defnav`

* BREAKING CHANGE: `path` renamed to `nav`

* BREAKING CHANGE: `fixed-pathed-path` and `variable-pathed-path` renamed 
to `fixed-pathed-nav` and `variabled-pathed-nav`

* Added `must` navigator to navigate to a key if and only if it exists in 
the structure

* Added `continous-subseqs` navigator

* Added `ATOM` navigator (thanks @rakeshp)

* Added "navigator constructors" that can be defined via 
`defnavconstructor`. These allow defining a flexible function to 
parameterize a defnav, and the function integrates with inline caching for 
high performance.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Clojure with Tensorflow, Torch etc (call for participation, brainstorming etc)

[kovas boguta]

On Tue, May 31, 2016 at 1:17 AM, Mikera 
wrote:

> I've been working with a number of collaborators on a deep learning
> library for Clojure.
>
> Some key features:
> - An abstract API for key machine learning functionality
> - Ability to declare graphs / stacks of operations (somewhat analogous to
> tensorflow)
> - Support for multiple underlying implementations (ClojureScript, JVM,
> CPU, GPU)
> - Integration with core.matrix for N-dimensional data processing
>
> We intend to release as open source. We haven't released yet because we
> want to get the API right first but it is looking very promising.
>

Looking forward to seeing this.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Clojure with Tensorflow, Torch etc (call for participation, brainstorming etc)

[atucker]

Given that the TensorFlow website invites people to build interfaces from 
other languages using SWIG, I guess they feel that access to the C++ 
component is the major thing.  So while I agree with Christian about 
reinventing the wheel, it may be that to interface at that level would 
involve reinventing only a relatively few spokes.
  I did an MSc in neural networks some years ago (before it was 
fashionable) and could do with brushing up on the latest.  I might be able 
to find some time for a straightforward task such as translating 
TensorFlow's Python into Clojure.
  A


On Tuesday, 31 May 2016 12:51:45 UTC+1, Christian Weilbach wrote:
>
> -BEGIN PGP SIGNED MESSAGE- 
> Hash: SHA1 
>
> On 31.05.2016 07:17, Mikera wrote: 
> > I've been working with a number of collaborators on a deep 
> > learning library for Clojure. 
> > 
> > Some key features: - An abstract API for key machine learning 
> > functionality - Ability to declare graphs / stacks of operations 
> > (somewhat analogous to tensorflow) - Support for multiple 
> > underlying implementations (ClojureScript, JVM, CPU, GPU) - 
> > Integration with core.matrix for N-dimensional data processing 
> > 
> > We intend to release as open source. We haven't released yet 
> > because we want to get the API right first but it is looking very 
> > promising. 
>
> Almost all of the development in deep learning is done in Python, so 
> having to reproduce this work on a different runtime (and language) 
> seems non-Clojure-like for me (compared to being hosted on the JVM and 
> leveraging this ecosystem). deeplearning4j is already attempting it 
> from the Java side with the argument of distributed scaling, but 
> again, there is a ton of work done for the Python toolkits including 
> massive scaling (e.g. with tensorflow) and most research is there, so 
> my question would be what the actual goals for a Clojure stack would be? 
>
> Machine learning systems usually can be implemented very well as a 
> "microservice" because they have no state (assumed the model is 
> trained and constant) and just need to return an output given a sample 
> (act like a pure function). This has worked out fine for me in Clojure 
> so far. 
> There are many other important machine learning concepts and papers 
> beyond deep learning, which can be used that way. The network IO can 
> be problematic in some cases ofc., e.g. small models+low-latency 
> requirement, but I think the leverage is much higher and will increase 
> unless the ML community switches away from Python to the JVM (highly 
> unlikely atm.). I personally will rather focus on ML papers and 
> improving the algorithm on paper and in Python than reimplementing a 
> ton of work in Clojure just to get on parity in my favourite language. 
>
> Another point is performance. For many areas it doesn't matter too 
> much whether you are 5 or 10% faster as long as you can scale. In 
> machine learning it is often critical though as these 5-10% are 
> already hours and scaling can be hard model-wise. I have tried to get 
> performance on par with Theano out of Clatrix (both on CPU) a year ago 
> and Theano was 2-4x times faster on my machine. Even if a Clojure 
> stack would address this, there is a lot of work necessary to 
> constantly optimize the stack for different GPU architectures and 
> compute graphs. Theano has atm. 40 contributors or so, not to speak of 
> TensorFlow being backed by Google & DeepMind now. 
>
> I think a much better approach would be to bring Python native 
> bindings to the JVM. There is http://www.jyni.org/ and they seem to be 
> getting closer to numpy support, but are only two guys atm. (I think). 
> While this is a more low-level effort and has little to do with 
> Clojure, it would allow to use all Python libraries natively from 
> Clojure (together with core.matrix backends for numpy, etc.). Jython 
> is considered as slow as CPython, so one could expect to have 
> Python-like performance with a small wrapper library, because most of 
> the performance critical code is already in the native libraries. From 
> there emancipating with Clojure through a core.matrix based-stack 
> would be a non-uphill battle similar to the development of the Clojure 
> ecosystem. 
>
> What points would speak against an approach like this? 
>
>
> Christian 
>
>
>
> -BEGIN PGP SIGNATURE- 
> Version: GnuPG v2.0.22 (GNU/Linux) 
>
> iQIcBAEBAgAGBQJXTXq+AAoJEICbLivqiPOFR1sQAKZYWzGz3mEFVQuItOUgFz8p 
> /zRh3oj2jLYOT5rHxEehZkZfQEjuRVMn6NW5nPR8c6mEzUc2FRNUTJHbDAgqaWSp 
> LxIOy5qfqzuA1J1x/hlsn1JRGMrvjZv+NvW2PpG8WSgZYwblIxdzzcRCYiRQ4+tQ 
> IhGDg1CKc2awGOJHLuJmzTuHtI+fIhvhDxRBEjvlfTdIInKugS5K0rwyiXr50jcx 
> zoO5jnhibcZB9LxskmW0J/8kH/hT2RD8mwjeI5oQYZuHZ/LvZX0+U9ocihyxoL2B 
> YFd2TwDc7ebgx71gsAnSTPcrIOfIwItprP4ka2gWtmXGJR3PZxfm5JlBir/gJIYf 
> Aa3uqR19qOFCgxwUCqFCWTVgojVFcF4F+VU7dXtfrQE5hkmBycSwbXiDh4CC11jV 
> Lhlff+yjv4OL2IYrPMBbVVU/KeWH+o4ETR0GaePRfGuBOEc04048F4Xz84NBZ6ke 
> lJhGL63JpUKqBJAPjZlU57VMoNMIczHdl

Re: set return value is unordered, is that a bug or by design?

[vandr0iy]

You could use sorted-map, if you wish to have them ordered:

https://clojuredocs.org/clojure.core/sorted-map

there is also sorted-map-by, which lets you define the
comparator based on which the values have to be sorted


On 05/31/2016 02:54 PM, james.naad...@gmail.com wrote:
>
> I would expect the returned set to be 
>
> #{1 2 3} but i get the following. Copied from repl
>
>
> user=> (set [1 1 2 2 3 3])
>
> #{1 3 2}
>
>
> user=> (set '(1 1 2 3 2 4 5 5))
>
> #{1 4 3 2 5}
>
> -- 
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient
> with your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send
> an email to clojure+unsubscr...@googlegroups.com
> .
> For more options, visit https://groups.google.com/d/optout.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

set return value is unordered, is that a bug or by design?

[james . naadjie]

 

I would expect the returned set to be 

#{1 2 3} but i get the following. Copied from repl


user=> (set [1 1 2 2 3 3])

#{1 3 2}


user=> (set '(1 1 2 3 2 4 5 5))

#{1 4 3 2 5}

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Clojure with Tensorflow, Torch etc (call for participation, brainstorming etc)

[Bobby Bobble]

> - Ability to declare graphs / stacks of operations (somewhat analogous to 
> tensorflow)
>

I'd be interested to know more as I've been working with factor graphs in 
Clojure with core.matrix, and it sounds related -- have you done anything 
like message-passing on graphs ? 

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Is there an apply-able new?

[hiskennyness]

On Friday, May 27, 2016 at 10:57:05 PM UTC-4, Brandon Bloom wrote:
>
> The new operation intentionally demands a statically knowable type to 
> construct. While this is true of Java as well, it's not true of JavaScript. 
> However, it is true of the Google Closure compiler's "type system" for 
> advanced compilation. That said, if the library you're using isn't going to 
> be optimized with advanced, you can do any typical dynamic metaprogramming 
> you'd want to do in JavaScript and call in to that.
>
> mynamespace.make = function(cls) {
>   return new (Function.prototype.bind.apply(cls, arguments));
> };
>
> Then from ClojureScript:
>
> (apply mynamespace/make qx.ui.mobile.form.Button ["Go!"])
>
>
Looking at this for the third time I am not sure what held me back the 
first two times. 

Thx, I'll give it a shot. This keeps coming up where qooxdoo decides some 
things should be constructor params instead of properties.

 -kt


>
> On Friday, May 27, 2016 at 10:24:12 AM UTC-7, hiskennyness wrote:
>>
>> qooxdoo lets us supply oft-used widget parameters to the constructor. For 
>> example, a button can specify its label and icon at new time. And this 
>> works fine from cljs:
>>
>>(new qx.ui.mobile.form.Button "Go!") ;; label is the first arg
>>
>> But I am wrapping qooxdoo in something more concise and want to be able 
>> to code:
>>
>>(qxia/make (::Button "Go!")
>>   ..other init params to be "set"
>>
>> Unfortunately I cannot even
>>
>>(new (qx-class qia-type)) ;; computed class
>>
>> Let alone
>>
>>(apply new (qx-class qxia-type) make-inits)
>>
>> Not that I thought I would get away with it. :) I grok new is special.
>>
>> I can fall back on the qooxdoo API and use setLabel and setIcon, but I 
>> like learning so I thought I would ask if there were some way to:
>>
>>1. compute a class (preferably by first constructing a name) and/or
>>2. do the moral equivalent of applying new to parameters
>>
>> -hk
>>
>>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Idea: standardised way of packaging docs inside jar

[Andrew Oberstar]

Not very familiar with it, but is the Grenada/datadoc project along the
lines you were thinking? I think that was a Google Summer of Code project
last year.

Andrew Oberstar

On Tue, May 31, 2016, 5:37 AM Arnout Roemers 
wrote:

> Hi all,
>
> This is a copy from the question I posed at codox
> :
>
> I was thinking that maybe a good addition to the Clojure documentation
> ecosystem would be to have a standardised way of including project
> documentation inside the project artefact (JAR). This documentation could
> then be searched and read locally (and offline!), and could also be
> aggregated on any of the community websites. So, in short, a kind of Ruby's
> rdoc for Clojure.
>
> I think the input (and maybe also the output?) of Codox is great for this.
> Maybe a good standard would be to put this in a META-INF/codox directory?
>
> How do others feel about this? Does something like this exist already, and
> did I just miss it? I'd love to hear!
>
>
> Cheers,
>
>
> Arnout
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Clojure with Tensorflow, Torch etc (call for participation, brainstorming etc)

[Christian Weilbach]

-BEGIN PGP SIGNED MESSAGE-
Hash: SHA1

On 31.05.2016 07:17, Mikera wrote:
> I've been working with a number of collaborators on a deep
> learning library for Clojure.
> 
> Some key features: - An abstract API for key machine learning
> functionality - Ability to declare graphs / stacks of operations
> (somewhat analogous to tensorflow) - Support for multiple
> underlying implementations (ClojureScript, JVM, CPU, GPU) -
> Integration with core.matrix for N-dimensional data processing
> 
> We intend to release as open source. We haven't released yet
> because we want to get the API right first but it is looking very
> promising.

Almost all of the development in deep learning is done in Python, so
having to reproduce this work on a different runtime (and language)
seems non-Clojure-like for me (compared to being hosted on the JVM and
leveraging this ecosystem). deeplearning4j is already attempting it
from the Java side with the argument of distributed scaling, but
again, there is a ton of work done for the Python toolkits including
massive scaling (e.g. with tensorflow) and most research is there, so
my question would be what the actual goals for a Clojure stack would be?

Machine learning systems usually can be implemented very well as a
"microservice" because they have no state (assumed the model is
trained and constant) and just need to return an output given a sample
(act like a pure function). This has worked out fine for me in Clojure
so far.
There are many other important machine learning concepts and papers
beyond deep learning, which can be used that way. The network IO can
be problematic in some cases ofc., e.g. small models+low-latency
requirement, but I think the leverage is much higher and will increase
unless the ML community switches away from Python to the JVM (highly
unlikely atm.). I personally will rather focus on ML papers and
improving the algorithm on paper and in Python than reimplementing a
ton of work in Clojure just to get on parity in my favourite language.

Another point is performance. For many areas it doesn't matter too
much whether you are 5 or 10% faster as long as you can scale. In
machine learning it is often critical though as these 5-10% are
already hours and scaling can be hard model-wise. I have tried to get
performance on par with Theano out of Clatrix (both on CPU) a year ago
and Theano was 2-4x times faster on my machine. Even if a Clojure
stack would address this, there is a lot of work necessary to
constantly optimize the stack for different GPU architectures and
compute graphs. Theano has atm. 40 contributors or so, not to speak of
TensorFlow being backed by Google & DeepMind now.

I think a much better approach would be to bring Python native
bindings to the JVM. There is http://www.jyni.org/ and they seem to be
getting closer to numpy support, but are only two guys atm. (I think).
While this is a more low-level effort and has little to do with
Clojure, it would allow to use all Python libraries natively from
Clojure (together with core.matrix backends for numpy, etc.). Jython
is considered as slow as CPython, so one could expect to have
Python-like performance with a small wrapper library, because most of
the performance critical code is already in the native libraries. From
there emancipating with Clojure through a core.matrix based-stack
would be a non-uphill battle similar to the development of the Clojure
ecosystem.

What points would speak against an approach like this?


Christian



-BEGIN PGP SIGNATURE-
Version: GnuPG v2.0.22 (GNU/Linux)

iQIcBAEBAgAGBQJXTXq+AAoJEICbLivqiPOFR1sQAKZYWzGz3mEFVQuItOUgFz8p
/zRh3oj2jLYOT5rHxEehZkZfQEjuRVMn6NW5nPR8c6mEzUc2FRNUTJHbDAgqaWSp
LxIOy5qfqzuA1J1x/hlsn1JRGMrvjZv+NvW2PpG8WSgZYwblIxdzzcRCYiRQ4+tQ
IhGDg1CKc2awGOJHLuJmzTuHtI+fIhvhDxRBEjvlfTdIInKugS5K0rwyiXr50jcx
zoO5jnhibcZB9LxskmW0J/8kH/hT2RD8mwjeI5oQYZuHZ/LvZX0+U9ocihyxoL2B
YFd2TwDc7ebgx71gsAnSTPcrIOfIwItprP4ka2gWtmXGJR3PZxfm5JlBir/gJIYf
Aa3uqR19qOFCgxwUCqFCWTVgojVFcF4F+VU7dXtfrQE5hkmBycSwbXiDh4CC11jV
Lhlff+yjv4OL2IYrPMBbVVU/KeWH+o4ETR0GaePRfGuBOEc04048F4Xz84NBZ6ke
lJhGL63JpUKqBJAPjZlU57VMoNMIczHdlMGF1oRhqkWzo0gD4ygX5C8g90xXGXLq
NjF/GiFEUWR1xzPvqLTNIX2kTveW46ZBDTiYCYCD8j+8yxGw04ow5wEoflbhz3Gd
PdWk7wb9bXlSHm6+b0Ax8CGQqMeDbb/RXqHneTDCQBjDW4olmzWfpRokUGj+K0ne
/1dgMs5AjIB+QHMW+PHZ
=3hFS
-END PGP SIGNATURE-

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit 

Idea: standardised way of packaging docs inside jar

[Arnout Roemers]

Hi all,

This is a copy from the question I posed at codox 
:

I was thinking that maybe a good addition to the Clojure documentation 
ecosystem would be to have a standardised way of including project 
documentation inside the project artefact (JAR). This documentation could 
then be searched and read locally (and offline!), and could also be 
aggregated on any of the community websites. So, in short, a kind of Ruby's 
rdoc for Clojure.

I think the input (and maybe also the output?) of Codox is great for this. 
Maybe a good standard would be to put this in a META-INF/codox directory?

How do others feel about this? Does something like this exist already, and 
did I just miss it? I'd love to hear!


Cheers,


Arnout

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.