Is someone around using Polilyth on production? https://polylith.gitbook.io/polylith/

Is there something like benzap/eden but using clojure’s syntax?

I would like to do embedded scripting in Clojure for my clojure program which can be compiled with GraalVM

@markx Assuming you are producing a native executable which no longer has a JVM available (and thus no Clojure compiler), if you have the ability to link your native executable to a JavaScript engine, you could use self-hosted ClojureScript to script things. This seems like a long stretch to get what I'm guessing you want, but thought I'd mention it as being technically feasible.

yeah I thought about migrating my program to cljs, but I feel eval is just too painful. Also I don’t understand how it’ll work with nrepl and cider and stuff if I use self-hosted ClojureScript.

To be honest, it is not clear to me what you are striving to achieve, and I'm speculating heavily.

hmm I don’t understand which part is not clear. Could you elaborate so I can rephrase my question?

You mentioned GraalVM and embedded scripting... are you using GraalVM to produce a native executable, but want to embed a scripting language into it that uses Clojure's syntax?

mhh i wonder if their new javascript implementation works in such an environment

doubt it tbh

(Meaning, a scripting language that still works in the native executable.)

Yeah, it’s like other typical embedded scripting, eg c++ and lua. You compile c++ code to a binary, and this binary will load lua files (scripts) at runtime.

I want to use GraalVM to compile my clojure program (host) to a binary, and this binary will load more clojure files (scripts) at runtime.

Currently I just use load-file to eval those scripts, which is not supported by GraalVM.

Right... that makes sense. So, your binary won't have the JVM available. (It will be native code at that point.)

using jvm clojure for that is a security nightmare

So, if you want to load a script-based on Clojure syntax, that script will have to be compiled.

and impossible =)

i would check if you can make javascript work

I'm just suggesting that one alternative is to embed a JavaScript engine in your binary. If you do that then self-hosted ClojureScript could be used to compile your scripts.

then maybe compile cljs to it

or even not self hosted

clojurescript is just a program, that takes input and produces ouput, no classes created

For example, Lumo and Planck are binaries, that don't have a JVM. Each has a JavaScript engine embedded / linked in it (V8 for Lumo, and JavaScriptCore for Planck). And each can dynamically compile and execute ClojureScript.

I ultimately would like to make Planck's guts available for native programs that want to embed a "Clojure"-based scripting language: https://github.com/planck-repl/planck/issues/936

This self-hosted/bootstrap cljs sounds very tricky, and I don’t understand all enough to use them.

It is indeed very tricky. If the issue above were implemented, you could just link to such a library instead. 🙂 But, it is not available yet.

an easy action item is : check if you can run some javascript from a compiled graalvm exe

I just can’t help complaining, why can’t cljs just come with the compiler? 😌 Ofc you could argue that on browser you don’t need the compiler anyway so you can save code size. But in my understanding, the one with the compiler should be the default version. :man-shrugging:

Hah. We still live in a world where delivered executable size matters.

Maybe in 10–15 years, self-hosted ClojureScript will be the default. 🙂

nah runtime weight will increase as fast as bandwidth

look where we are with our supercomputers in a pocket, and still programs are slow and instead of 1mb, they're now gibabytes

I’ll probably rewrite my program in Go and use something else for scripting then. :man-shrugging:

the question is, why do you need a compiled program ?

because it’s a tui program, and I want to run it on my phone using Termux.

gui ?

Tui like https://en.wikipedia.org/wiki/Text-based_user_interface

i'd go with self-hosted clojurescript then, an easy choice

Hrm. Just compile Planck for your target and run it in there.

or that yes

Then you could write your TUI in ClojureScript.

the security aspect though ...

I mean, if someone wants a program running on any device, and that program has the ability to load programs, in any language, into it, then that person owns their security goals (or non-goals). Sandbox it if you can, or let anything run (which might be markx's goal -- I don't know)

Maybe the program is just for Ke's use?

sure, but there are many cases where you might want a scripting language that only accesses what you allow, see the browsers as a common example

The JVM was originally developed to be run in web browsers, and has a kind of security model associated with it, and you can put restrictions on what it can load and execute if you work enough at it.

I'm not advocating that markx get a JVM running on their phone here, by the way.

already has one on the sim card !

=)

Just install Clojure in Termux and call it a day. 🙂

and emacs with cider, then just go C-c M-J to jack in clojruescript =D

Sure, Planck ships with the self-hosted ClojureScript compiler.

Same is true for Lumo.

So I just use Planck when I run my program. And for dev I still use normal cljs?

Essentially, yes.

Does Planck work with shadow-cljs? I imagine I would be using many js/node libs and I probably will want to use shadow-cljs for dev.

No. But. With Planck you'd probably resort to using something like Webpack to extract a NPM library. But if Node support is important to you, Lumo is much better in that regard.

Lumo essentially is Node.

i think the react native people are having a nice workflow with reloading on the phone, so it must be possible, might be worth investigating there

But Lumo doesn’t work with nrepl and stuff, right?

I’m very confused. I might be missing something here.

Can I use nrepl and cider and stuff if my app needs to run with lumo?

You can connect work with Lumo from Emacs, if that's what you are asking

(It doesn't support nREPL, but there is evidently an Emacs mode of some sort to hook into it.)

It looks like Lumo isn't built for Termux, so you'd need to sort that out.

hmm I don’t use Emacs. I use vim. So far I’ve been using fireplace with nrepl.

Yeah termux has node, so it might not be that hard to get lumo running. But again, this is so tricky. So many hacks to do. 🙂

Anyway, thanks for all the info!

well running a terminal in a phone is already more than a step into hack land

If you just want to run something textual on and Android device, and it doesn't necessarily need to be in Termux, you could fork Replete for Android, and revise its UI from being a REPL to being a textual display of some sort. 🙂

use pure clojurescript, have your script writers compile theirs to javascript

so now you have two scripting languages ! cljs and js

Hey guys, I am trying to generate java class for Clojure namespace. In that namespace I have a method which can take string or map depends on user. What should I define :methods definations of gen-class for that methods ?

@rulz.gupta First off, I'd say "don't do that". In general, a function that can take completely different types for a single argument is poorly designed.

If you refactor it to two separate functions, it then becomes easy to generate a class from it. And, yes, in Java you could overload a method to take a String or a Map but it's still poor design in general. Constructors are about the only place that's excusable, IMO.

anyone know what it the minimal version of JVM/java for running the actual clojure?

suppose I have a really old legacy systems where as usual nobody want/can update

what could be the requirements in term of java/jvm for running the current clojure

(thinking in term of backward compatibilty..)

Java 8 or higher

@alexmiller thx! I was wondering, in the release notes of clojure is this stated the requirement binded to java?

Another Java noob question. I heard time ago that jvm licenses has changed. Has this any consequence for clojurians open-source code and or for legacy?

jvm license has not changed, still GPL

Ah OK thx. So it is Java license but OpenJdk is still free

Afaik

if i have a collection shaped like this: [[:foo [:inner1 :inner2] :bar [:inner3 :inner4]] and i want to transform this into [[:foo :inner1] [:foo :inner2] [:bar :inner3] [:bar :inner4]] is there a more elegant way to do this rather than a reduce?

i'm thinking there must be a zip or something solution but i'm not seeing it atm

it's straightforward with reduce

partition and mapcat could make a none reduce version

you can't really create the right structure with mapcat

you can use for after the partition

(mapcat (fn [[x ys]] (map (fn [y] [x y]) ys)) (patition 2 data))

oh that's nice

otoh, maybe @noisesmith is right and reduce is probably the easiest-to-understand function

(let [data [:foo [:inner1 :inner2] :bar [:inner3 :inner4]]]
  (for [[x ys] (partition 2 data)
        y ys]
    [x y]))

(for combinotronics for is really nice)

maybe this is actually a task for specter / meander / something else

yup

(mm/search [[:foo [:inner1 :inner2]] [:bar [:inner3 :inner4]]]
            (scan [?k (scan ?xs)])
            [?k ?xs])

(this is meander)

With that you've introduced the meander DSL, making it less elegant and readable IMO.

I certainly find the for above much easier to read than meander.

I agree the for implementation is the nicest

or at the very least more simple

here a deprecated function is still used: https://github.com/clojure/clojure/blob/653b8465845a78ef7543e0a250078eea2d56b659/src/clj/clojure/test/junit.clj#L118

just fyi, it's not bothering me personally 😉

Has anyone used VisualVM for profiling memory consumption? I need to profile memory consumption of a namespace but it seems like VisualVM can not find my namespaces. How can I make them visible?

a namespace contains a hash from symbols to vars, you could follow the recursive usage of memory from that root into the objects in the vars

one hack is to replace a suspect hash-map with a defrecord, the profiler makes it easy to check the nested memory usage of that record's class

"memory cosumption of a namepsace" is unlikely to ever show up in a profiler how ever you profile things

namespaces are mostly collections of static data which is mostly by nature small

so "I need to profile memory consumption of a namespace" sounds like trying to force clojure namespaces in to a java class shaped hole, which they don't

Oh I see, so defrecording suspect data structures is a way to go, thanks!