Fork me on GitHub
#meander
<
2022-10-03
>
Daniel Slutsky06:10:02

Summary & recording of the #meander data-recur meeting last Friday. Thank you so much for the brilliant hands-on teaching, @noprompt! https://clojureverse.org/t/data-recur-meeting-3-meander-summary-video/ https://www.youtube.com/watch?v=t8C5Uv1abc4

🎉 7
noprompt15:10:58

Just a note about this, I'm not particularly great a presenting/time management during a presentation and didn't cover as much as I would have liked to. For people who already know about the library, there's nothing new here. For people new to the library, I think the docs are probably going to be the most effective way to learn Meander.

prnc17:10:43

I loved it actually! 🙂 Docs are great but I think there is something to be said for seeing someone skilfully use a tool, small mistakes, detours and all — it more closely resembles the actual usage context — gives one ideas and confidence to try them out 💪 So thank you!

👍 1
🙏 1
noprompt17:10:41

Question: are the Clojure ML folks largely on Zulip?

noprompt17:10:17

I took a peek at tech.ml.* on Friday and I want to learn more.

noprompt17:10:35

(Currently learning pytorch and working through the fastai book.)

Daniel Slutsky18:10:12

> largely on Zulip? yes

Daniel Slutsky18:10:18

> I loved it actually! 🙂 > Docs are great but I think there is something to be said for seeing someone skilfully use a tool, small mistakes, detours and all — it more closely resembles the actual usage context — gives one ideas and confidence to try them out 💪 > So thank you! I felt the same. To me, this seems the best path for learning such a topic, and also the best path to prepare for more advanced topics. For live coding to be clear & didactic, it needs to be slow enough. It actually made sense to spend that time with Meader basics, in my opinion.

👍 1
noprompt15:10:46

Usage poll 1️⃣ I use Meander for hobby projects 2️⃣ I use Meander for/at work 3️⃣ I don't use Meander

2️⃣ 11
1️⃣ 11
3️⃣ 4
noprompt15:10:31

I don't use Meander because 1️⃣ I don't understand how to apply it 2️⃣ It's too buggy/hard to debug 3️⃣ There is not enough documentation 4️⃣ Other (specify in reply)

4️⃣ 4
2️⃣ 3
3️⃣ 3
Anthony21:10:11

4: ... yet, but plan to

Lidor Cohen21:10:14

I use it at work for some tasks and specter for others. I was able to grasp specter a bit better (although I used meander first). They are both missing aggregations.

noprompt21:10:55

> They are both missing aggregations. @lidorcg Aggregations exist on the zeta branch and to a degree are also available on the epsilon branch as memory variables. An "aggregation" on the zeta branch is actually just custom variable type which is simply a pair of rewrite systems (functions). The first function takes, as an argument, the current state of the variable and a value to be stored, and computes the new value of the store AKA fold. The second function task, as an argument, the current state variable and computes a pair of the value to return from the store and the next value of the store AKA unfold.

;; Store a value
[current-state incoming-value] -> next-state
;; Dispense a value
current-state -> [outgoing-value next-state]
This generalization of variables is suitable to accommodate virtually any kind of aggregation, be it min, max, a counter, an average, etc. Counter already exists as ++ on zeta. Its fold simply increments the stored valued while ignoring the incoming value, and its unfold simply returns the stored value.

noprompt21:10:49

The only thing this description lacks is an account of failure, both in the fold and in the unfold. Fortunately, zeta does account for this and the definition of variables/aggregators can specify a how storage/retrieval can fail. For example, we can say that if a variable has never stored anything it is unbound. Retrieving an unbound variable could mean failure (in most programming settings this would result in a compile time/runtime error).

Lidor Cohen09:10:04

@noprompt thanks for addressing that, on the last task the required group by and aggregation I posted a question here and after a little search on the channel I found an answer that basically said "we're working on it" so I rooted for you and solved it in the old clojury way 😁 . Next data manipulation task I have I'll come back to meander and will give it another go 💪:skin-tone-3:. I always seek different tools that give different perspectives on problems, and meander sure is different so I'll keep on checking on it

noprompt15:10:59

I will probably think of some more questions. Also, I think there is a proper poll thingy for Slack but I don't know where it is.

noprompt21:10:55

> They are both missing aggregations. @lidorcg Aggregations exist on the zeta branch and to a degree are also available on the epsilon branch as memory variables. An "aggregation" on the zeta branch is actually just custom variable type which is simply a pair of rewrite systems (functions). The first function takes, as an argument, the current state of the variable and a value to be stored, and computes the new value of the store AKA fold. The second function task, as an argument, the current state variable and computes a pair of the value to return from the store and the next value of the store AKA unfold.

;; Store a value
[current-state incoming-value] -> next-state
;; Dispense a value
current-state -> [outgoing-value next-state]
This generalization of variables is suitable to accommodate virtually any kind of aggregation, be it min, max, a counter, an average, etc. Counter already exists as ++ on zeta. Its fold simply increments the stored valued while ignoring the incoming value, and its unfold simply returns the stored value.

noprompt21:10:49

The only thing this description lacks is an account of failure, both in the fold and in the unfold. Fortunately, zeta does account for this and the definition of variables/aggregators can specify a how storage/retrieval can fail. For example, we can say that if a variable has never stored anything it is unbound. Retrieving an unbound variable could mean failure (in most programming settings this would result in a compile time/runtime error).