:thinking_face: “def a fn that dispatches by event to an anonymous fn which is registered by that event.”

Out of curiosity, why not just register events and not def fns?

well, 'often' probably not often, usually I don't have to

what would a function say assoc-map look like, that takes in a map1 and another map2 and assocs in map1 into map2, basically embeds map1 into map2?

like a way to recursively iterate through a map

(defn deep-merge "Recursively merges maps." [& maps] (letfn [(m [& xs] (if (some #(and (map? %) (not (record? %))) xs) (apply merge-with m xs) (last xs)))] (reduce m maps)))

works really well

Thanks!!

There are some pre-defined character classes in Java RegEx. E.g. \p{IsAlphabetic} can match any Unicode alphabetic characters. They are sometimes useful. https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html

This works too, \p{IsAlphabetic}+(:\p{IsAlphabetic}+)?

It wasn't easy but I really like the result(performance/maintainability). Hopefully future releases/apps wouldn't be as difficult

What did the more difficult part for you ?

The most difficult part was absense of someone with practical experience in clj/cljs ecosystem so I had to explore all those(fantastic) choices myself. So my onboarding to CLJ world was rather tough - started with Luminous(clj/cljs), then got excited about Fulcro(still got stuck after a few weeks of learning it), switched to macchiato(got it working locally but couldn't make it into production - slack channel and macchiato's small community is rather very small so I can't complain). Eventually I rewrote it using Luminus stack hoping Heroku's 512Mb RAM limit would be enough). I'm currently monitoring this app - RAM usage is steady at 60%(318Mb), performance it really good

Clojure community is super friendly and super helpful but when you have deadlines.. you can't just spam it with dozens of questions every hour 🙂

same problems here too, sometimes I was waking up 2 AM and 3 AM just so I can ask questions on the slack since in my timezone either people were sleeping or working, so not able to answer.

It's a bit easier if one can setup a CI pipeline, but the whole cloud direction is like getting in brace with Bezos, I am not sure how that's going to work out. OTOH, the language itself would benefit from more diversity anyway, so each possibility has it's ups too.

The time zone issue is real. If you post something at morning time(in Europe), there is high chance no one gets to it by the time America wakes up 😄

which is late afternoon, early evening. If you want to have a conversation that goes back and forth a few time, it's quite expected to take until 22:00 there is some exhaustive resolve

Thank for the details @U0113AVHL2W 👍

https://clojure.org/reference/reader#tagged_literals it is tagged literal

Thanks! Do those that turn regular data structures into more specific kinds have a special name? Because there are other kinds of uses for #something, right?

Actually in this case I think that’s a Java constructor, not a tagged literal

It happens to be a Java constructor for a Clojure record in this case

Are there any docs for all possible uses/meanings of #?

interesting, thanks for noticing that @U064X3EF3

https://clojure.org/guides/weird_characters is probably the closest

In general the # is the character that triggers the dispatch reader

You can actually find the definition of the dispatch table here https://github.com/clojure/clojure/blob/30a36cbe0ef936e57ddba238b7fa6d58ee1cbdce/src/jvm/clojure/lang/LispReader.java#L109

So that says what to do based on the character after the #

That is so cool! I will have to learn to read the java source eventually 🙂

I think it will complain about mixing fixed arity with variadic one

ah right, you might need to get rid of the no arg there

(defn foo
  ([] (foo {:a 1}))
  ([{:keys [a] :or {a 1} :as m}]
   (if (map? m)
     a ;; here should be actual function code
     (foo :a m)))
  ([a & args]
   (foo (apply hash-map (list* a args)))))

(foo)       ;; => 1
(foo 2)     ;; => 2
(foo :a 3)  ;; => 3

but I would not recommend to use it) probably not the best way to structure function api

for a large part it's recognizing how Clojure's design decisions are meant to be simple, and making things that are compatible with those choices

you’ve probably already seen https://www.infoq.com/presentations/Simple-Made-Easy/ , but just in case

I think the biggest items: use immutable things, program in terms of values, use abstract structures not domain specific ones, prefer 100 functions on 1 data type over 10 functions each on 10 data types

but that's just my elevator pitch version

when thinking about simplicity, a decent place to start is trying to break down your design down into who, what, where, when, why, and how. it’s a very concrete place to start which should hopefully get the wheels turning.

hey thanks for the answer I m familiar with the suggestion, i guess my question aims more for the bigger picture. Like when i desing a system. How to judge if it is still simple after writing a lot of code

hope this makes sense :thinking_face:

ideally, you want to produce a “simple” design before you write a lot of code

if you haven’t, chances are good that your design isn’t simple

ur right a problem has to be understood

but i guess more clearity will come with more experience

i’m not really a TDD (test driven design) person, but TDD will highlight where your design isn’t simple. basically, if your design is simple, then you can take your program apart. if you can take your program apart, then it’s typically much easier to test

ye makes sense

some questions you can ask to see if your design is simple: • is your program built from smaller pieces? • what are the smaller pieces? • can the pieces be used in different contexts? • can you run a piece of your program in isolation? (ie. can you run a part of your program without setting up a context that requires the rest of your program)

I definitly will try this

really appreciate ur input and thanks for the effort 😍

Focus on data and values instead of complicated abstractions and wrappers. When you have data you can apply powerful Clojure functions to it. Simple is good. It means you can use tools you are familiar with and not have to guess how you are supposed to deal with something. All the problems start to look familiar and tractable. (as opposed to, for example, having to learn a new API every time you interact with a different object/class)

@U013CA8A28J ty for ur input, clojure makes this approach especially easy. Where I struggle is when I try to apply these ideas in other languages for example java. Do u have any resources or examples outside the clojure ecosystem where the principles of "simple" are applied?

@UP2FUP0TT Are you asking how you can make Java as simple as Clojure? Oh, that made me laugh 😆. You cannot. It is designed around the class system. Java code can only take the ideas so far because the language doesn't help you. You can do certain things, like rely on factory methods instead of instantiation with new. That simplifies things for you, but much of this way of programming depends on the language itself. Take JavaScript as an example. There, your functions are first class and you have data literals just like Clojure. That makes it a lot easier. Many of the "patterns" of Java just fall away and you use functions/literals instead. There is a really great talk by Douglas Crockford where he brings up something called "parasitical inheritance". It's like a decorator pattern. Say you have a function makeDwelling which produces some kind of specification map for houses, like number of rooms, area, furnishings, etc. You could then create a new function that specializes on top of that, such as makeLakehouse: function makeLakehouse() { const house = makeDwelling(); return {...house, hasLake: true }; } Nice and simple. No need for classes or any rigid hierarchy. You basically have a factory function and then use it as part of another factory function. It sounds almost ludicrous to call it a factory function because it's so simple. You get nice encapsulation and the ability to change the implementation later. In Java, this is simply not an option. No matter how you decide to implement it, you must use classes and methods, and you'll probably have getters and setters. There will be boilerplate. It's just the way it is. JavaScript has its own problems, but you can at least choose to simplify your life and use the nice parts of it.

If you don't mind paying, I would recommend contacting Eric Normand at https://purelyfunctional.tv and find out what he might charge, or if he has recommendations for tutors.

Clojure tooling tends to be somewhat disparate, with at least 5 major different IDEs/editors each with their own Clojure-specific add-ons, Clojure vs. ClojureScript, etc.

There are specific channels on this Slack for all of them that I know about, e.g. #cider #emacs #calva #cursive #vscode #clojurescript #shadow-cljs #figwheel etc.

Thanks @U0CMVHBL2 I'll try Eric! Not sure if its an IDE problem or user problem (me) but I've been having a hard time getting programs from tutorials to run on my machine, looking to break through that barrier so I can learn by emulating

@U0135E0PFDX, you may find https://exercism.io/my/tracks/clojure and #exercism useful

thanks @U7RJTCH6J that looks like a great resource

I can highly recommend Eric's videos and he is available for you 24/7 via e-mail, very excellent service he provides! Take your Clojure to the next level with some of his excellent videos.