Interesting. Have you looked at Liquid?

Yeah, that's definitely an inspiration

There's probably a really easy way to do it, but I'm implementing the low-level terminal stuff in C just for fun:stuck_out_tongue_winking_eye:

I would check out the ed editor

yeah the idea is basically a "multiline ed"

oh you mean actually look at the source for ed?

I mean like, just implement ed in the repl

You don't need to do any of the terminal stuff

Ed can run in any clojure.main/repl because it just needs streams

Then you can start looking at acme, the plan9 editor, which is basically a gui front end that feeds commands to an ed style backend

oh cool!

not sure if I made it clear, the low-level stuff is to get the terminal into raw mode, to facilitate full cursor movement, like Vim, but without clearing the screen or anything

I wonder if you could embed neovim into this... That would be novel.

I initially thought that to be not in the spirit of this, since the point is to not break the flow of your shell activity. But I could see it supporting extension modes (kind of like how vi began as the visual mode for ed), in which case Neovim would be the ideal candidate!

No, the guide is pointing to the currently released version of spec. https://github.com/clojure/alpha.spec is "spec 2" and still in development. Some things in the guide will work differently in spec 2.

oh, I totally misunderstood what you were talking about. fixing.

Isn't this just filter?

(filter #(-> % :name (= "value-of-interest"))
        [{:name "example"} {:name "value-of-interest"}])
;; => ({:name "value-of-interest"})

I’m getting the first result of filter. I was mostly just wondering if there was some clojure function left to discover. Like using when-some in some fancy way or something.

I would probably write this as (first (filter #(= "value-of-interest (:name %)) coll)) because it makes it very clear at a glance what is happening. (And it is about equally succinct.) I don't know of a shorter way to write this with core functions.

Yea this seems like the best option tbh

Another caveat of using filter - even if you use first, it will still create a longer sequence thus calling the predicate multiple times.

That's a fair point. For my personal taste, I would still use filter for the improved readability unless there was a nontrivial, measured performance penalty for the choice.

I vote for filter as well. The example with some is a little difficult to parse.

Yea it’s not a very large vector. If it was a very large vector I think some would make sense.

Do check out core.match. It can make your matching logic more succinct. https://github.com/clojure/core.match/wiki/Basic-usage#map-patterns

I would build up your own functions so that it can be terse. like seek or find-first or ((index-by :name data) "value-of-interest")

To be clear, filter will consume 32 items at a time; it will not call the predicate on every item in the collection up front (unless the sequence has 32 items or less).

i pretty rarely seek for a specific item. tend to use indexed data structures and retrieve what i want via simple map lookups (almost always only ever iterate a seq once)

And that's the exact reason why something like find-first doesn't exist in the stdlib. There was a ticket for fast implementation, and it was declined with that reasoning.

yeah, just pick the right data structures and it's often a non-issue

Yea I’m doing this now. Went further into the code to find what is depending on the datastructure and changed how it is destructured.

IMO find-like functions are useful and I have several in my utilities namespace. Yes, you could create a faster access path, but sometimes that's not the best thing. If it were always the best thing, that is an argument for not having some .

does not seem that low to me - I've run apps with less, but it really depends on what you keep in memory

How much less? I don't remember anybody recommending less than -Xmx256m for production.

I'm actually very surprised by this! At some point we just thought using the JVM meant paying 1GB of RAM upfront. But still, seeing our python services takes as low as 15MB makes me feel envy 😭

I'm running one of my simple clojure apps with -Xmx256m and it works just fine. It might be worth exploring why your tiny clojure app cannot do that. And I've just tried it with -Xmx128m and it seems to work well.

It may depend on particular GC too - if you want the GC to return memory to OS then G1GC (since JDk 12), Shenandoah and ZGC (not sure from which version, might be only JDK14) and of course Azul's C4 support that.

Shenandoah might be better positioned to your use case (memory constraints), also because ZGC doesn't support compressed oops

my experience with G1GC in our system is that memory is never returned to the OS :S But maybe I misconfigured something.

What JDK?

it should be in newer jdks with g1gc

I was looking into Shenandoah and indeed looks like our best option! But sadly, the JDK included with the clojure docker images seems to lack support for it 😞

Again, what JDK? 😉

yes, sorry, JDK13

Ah, so at least G1GC should support that: https://openjdk.java.net/jeps/346

But perhaps don't be too obsessive about that. Could be good to figure out why you got OOM - did it come from your app code?

Also setting some goal could be helpful - you for sure aren't going to achieve 15MB memory footprint but perhaps it even doesn't make much sense

I'll look into the source of OOMs, maybe there's some clue there.

And I was definitely not attempting to achieve a 15MB memory footprint in anything JVM 😅 As you say, it probably doesn't make sense either.

Yeah, stacktrace could be helpful 🙂

And if you want to use ZGC, then I'd highly recommend upgrading to JDK 14: https://malloc.se/blog/zgc-jdk14

Note that both ZGC and Shenadoah (afaik) are still "experimental" - they could potentially break (or silently corrupt) your app in some rare circumstances; In practice, I think, many people are already using them just fine.

Funny enough, I've got better results (on Mac with JDK14) running with the default G1GC when trying the ZGC - was able to run with as little as -Xmx18m and the whole process is taking about 140m

I've worked with a web app + mysql which have problems handling number of requests above normal. We have to tune the webserver & JDBC thread pool settings.

I should be specific as well, they were discussing ‘multiple execution contexts’. But yes, I’ve definitely seen the need to bump settings on the JVM and JDBC settings

this seems unlikely to be related to the some fn, which is pretty simple

How is a change in jobs triggering a re-render? Is this in Reagent?

I have these two things in my template.

[:h1 (some #(not= "idle" (:status %)) jobs)]
     [:h3 (map :status jobs)]

@UJRDALZA5 it is in hiccup using Ring/Compojure. We have it refreshing every 2 seconds

So, after job completes, you want :h1 to disappear?

Yea. I mean this is just debugging purposes atm. But some should return to a nil response.

Can you put a (prn jobs) somewhere on page? Does that change?

Well the map clearly shows that all jobs are idle

So to me it’s like some is caching it’s result and then just not running again…?

prn will give a literal representation, just wanted to check the type of "idle" is still a string. Just a random thought.

Damn strings

it was being updated with "idle "

Yeah, pr/prn are great debugging tools. Works with deeply nested structures too.

Note the space at the end lol

I haven't read all followups to see if this has already been suggested, but you could maintain a sorted collection to avoid resorting, and also a hashed collection for usually-faster membership checks, and keep their elements in sync with each other. Those two things could be wrapped inside a deftype or similar if you wanted to hide those kinds of details

Bad assumption in this case. Maintaining the sorted order and using a hash function for lookups essentially means you need two different trees, one for maintaining the structure of the sordidness, and the other for the structure of the hash values, selected several bits at a time (5 bits per tree level in Clojure's hash-map implementation)

Why not use a built in query in elasticsearch? Like a terms query?

because I won't know how many flowerIds I will have in the vector, I could have 1 or 100s

that is fine?

If it can be more than 10k, then batching once you get more than 10k is necessary

100s is not that big of a query to hit ES with

But anyways, somebody who is more an expert in Clojure can talk about pmap, but batching as many as possible together in the same query will be way faster for Elasticsearch.

pmap is almost always the wrong solution.

We use ES heavily at work and we use "id in list" / "id not in list" style queries a lot.

100s of IDs isn't a problem (1,000s might be).

a bit of propaganda, but #pathom solve this kind of lookup problem

@seancorfield there is no cases where 1k ids will be query.

Terms query worked wonderful

https://www.braveclojure.com/

Heh, I totally got the book title wrong in my original post!

I like http://clojurescriptkoans.com/ Last time I tryied Exercism I feed that the exercises force you to think in procedural way, so I dont recommend it.

Ooh nice, I’ll check that out! I enjoy learning things in a more hands-on manner, but so far the exercises I’ve been doing haven’t been pushing me to learn as much as I would have hoped.

I'd recommend either Living Clojure (Carin Meier) or Getting Clojure (Russ Olsen). Those are both supposed to be really good for learning Clojure.

Programming Clojure 3rd Ed is a bit more advanced. Then Clojure Applied for "real world" stuff.

Thanks Sean! I’ll check one of these over the “WFH break” and see how far I can get.

https://clojurecademy.com/

I liked The Joy of Clojure a lot many years ago. Maybe not the best one for starters, but still very good

I second The Joy of Clojure, especially if Clojure won't be your first programming language

@U2J4FRT2T Just finished the koans you linked, that was pretty cool! There were a couple concepts I haven’t ran into before, I’m interested to see how they can be used going forward

I started reading the preview chapters for The Joy of Clojure and am really enjoying it! It’s refreshing to have a book be faster paced and be focused on the things I’m actually wanting to learn for a new language. Thanks for the tip!