Clojurians Log v2

The typical formula here is test lib + http lib. There isn't a reason for those to be bundled.

I made an #http-kit channel

Does anyone have experience with https://zio.dev/ ? If so, could you share that and what you think about it?

TIL: https://www.darlinghq.org/

Hello, everyone :). I wonder how the knowledge and experience acquired writing and designing Clojure programs can be leveraged in other languages? I really appreciate the default idioms if Clojure and wondered which one where easily transported in other languages, such as python?

I used to have a day job in PHP and I tried to apply some Clojure principles where I could. You can, for example, have a class that has basically no data fields and all static methods, and that works like a Clojure namespace, assuming the methods use a lot of generic data types like arrays and hash maps. And you can avoid using inheritance and global variables.

I have no experience using immutable data structures in production code in languages other than Clojure, but Python already has immutable tuples and frozen sets. There is no frozen dict, but I have written tiny-to-medium sized Python programs that used mutable dicts instead of creating custom classes for data before, in the Clojure style of 'just use maps' for collections.

The down side is if you’re on a team and they want to write plain vanilla PHP/Python/etc, and they look at your code and go bleh.

Several languages have immutable persistent collection libraries for them, some also inspired by Phil Bagwell's work and others, and in some cases directly inspired by Clojure's implementations of them.

e.g. JavaScript immutable.js, Scala <something>, and I suspect probably dozens of others.

The main thing Clojure did for my PHP programming was teach me a new way of looking at problems and how to solve them.

ZIO is an effect system coupled to a dependency injector. Both ideas are great, but unifying them in a single abstraction is questionable IMO

I've not used it in anger but from what I've heard it's solid tech

Can someone point me to how to actually search at https://clojurians-log.clojureverse.org/ ? I only seem to be able to click on specific channels, then dates

you can google search on a specific site (general tip)

yeah I just played with that, basically site: operator, kind of works

thanks for the reminder

@jeffrey.wayne.evans You can also use the Zulip archive. E.g. to search in the clojure-spec channel: https://clojurians.zulipchat.com/#narrow/stream/180378-slack-archive/topic/clojure-spec

thanks for the suggestion, @borkdude!

I know the feeling. I was learning FP through our JS codebase and the other devs didn’t like it because it wasn’t as easy even though it made a lot of systems way simpler, deterministic, and scalable. They sometimes would give it a try but as soon as any obstacle was encountered they would bow out to an OOP solution often introducing mutable state.

It was hard to stress that it works best when our system uses FP as a default to reduce stateful complexity as much as possible instead of just using it at the edges when we could slow down to try and learn it.

Another challenge was trying to express that it isn’t just about FP as a coding style, it was about having a common set of principles that guides our entire design process for interfaces and functionality.

Oops I’m quite chatty today. Didn’t mean to hijack your convo, I guess your post took me back to the dark times.

So, I always trip over modeling this kind of problem and I'm wondering if anyone has any advice. What I'm trying to express is that y should be modified inversely to the magnitude of y. so like, ideally as y approaches 0, the change in y is reduced. but of course, when y is less than one, 1/y > y

what is the operation I'm actually thinking of here?

"delta y is inversely proportional to y"

If smaller y means smaller change, then "delta y is proportional to y" is closer to that meaning

you could do something like y = y * 0.8

new_y = old_y + constant * old_y is the only formula that strictly follows the interpretation of "delta y is proportional to y", at least according to the meaning of "proportional" that I know.

err, right. I have this example kind of backwards, because im actually applying a counter velocity, so I want the size of that counter velocity to be greater the greater y is

where constant can be a negative number in my formula.

y = y * k, where k is some constant which is how friction works

I think

err, wait, my mental model is definitely screwed up, so I'll just explain the thing. the thing is a spring. I want the damping of the spring to be less when the spring is in an extended position

Is damping in any way related to 'force'?

so a regular spring dampening would be y * -k * deltaTime

where y is the displacement, or current degree of extension of the spring

negative k because its a force applied in the opposite direction

The ideal spring law I learned in physics was that many springs exert a force that is a constant times the distance that the spring is away from its rest position, which is 0 at its rest position, positive in one direction, and negative in the other, so the force is always directed back towards rest position.

right, which is hooke's law, which is the formula I just wrote

except Hooke's law relates force and position, and has no deltaTime in it. But I am guessing that you are doing some kind of discrete time simulation that approximates continuous time?

yeah but hooke's law doesn't have to deal with a nondeterministic timestep in between applications of the formula lol

this is correcting for the fact that I'm in a discrete nondeterministic environment and I calculate this factor in discrete steps. I need the dampening to increase as the spring approaches its rest position, because otherwise the spring overcorrects and picks up too much acceleration and never comes to rest

Many discrete time simulations of physical systems maintain position and velocity of objects at all times of interest, calculate forces, add up the net force on each object, then do "new_velocity = old_velocity + F / object_mass", then take the velocity vector times delta_t to get an offset that the object moves during delta_t

right, yeah. thats another reasonable way to do that

I might have that new_velocity formula off a bit there .... been a while.

F/m is acceleration, and perhaps that needs to be multipled by delta_t, also, to put it in units of velocity.

well, anyway I appreciate the input. the deltaTime business isnt where the confusion here lies. thats just a constant that gets applied to any force that occurs in a frame

When you say nondeterministic time step, are you saying that you aren't simply making delta_t a constant in your simulation, but that it is expected to change from one discrete step to the next, for some reason?

in theory, you get to pick the deltaTime for each step of the simulation, but if you're trying to display the simulation in realtime, your deltaTime may vary to match your frame rate

Oh, if by dampening you mean friction, then yeah, that is one of the forces involved, completely independent of the spring restoring force, and many objects have an approximate friction force that is "- c * velocity_vector", where c is called the dynamic coefficient of friction, IIRC

So you would want to calculate both of those forces at each time step, and add them, before calculating the new velocity.

but note that the friction force is not proportional to the current offset from the rest position, it is proportional to the current velocity vector.

So the friction force is actually greatest when the object is moving fastest, which in an oscillating spring is going to be when the offset from rest position is 0, i.e. the object zips by the rest position faster than at any other time during its movement, in a single 'sweep'

Though I’m curious, did you try demos, pairing and tutorials to win them over? Or did they just encounter it in code review?

Basically what it comes down to is that I want a function that takes some input x and produces a y between 0 and 1, where y is larger the closer x is to 0

so... that sounds kind of like cosine

its cosine-ish

if my input range was between 0 and pi, then that would be true for cosine

There are an unlimited number of such functions, if you don't need the damping effect to behave like friction.

https://en.wikipedia.org/wiki/Normal_distribution#:~:text=The%20normal%20distribution%20is%20the,a%20specified%20mean%20and%20variance.

e ^ (-x^2)

oh wow

can you not just do the absolute value of the cosine?

yeah this actually might be exactly what I need

That would decrease up to pi, then increase again, which may not be what he's looking for

ah, yeah

if one knew the maximum distance from the rest point, you could scale that distance so it was in the range [-pi, pi] and use cosine

I think e ^ (-x^2) is perfect, actually

I can just multiply x by another constant to customize for the shape I'm after

huh, man...

The base can be anything, e.g. 50 ^ (-x^2), which is just another way of scaling the shape of the curve.

But e is pretty cool.

oh its not a special property of e ? lol, shows you what I know

Any positive real number raised to the power 0 equals 1, so any positive number works there

man thats awesome. Im really, really happy to have (I'll just sub in k) k^(-x^2) pattern available. I feel like I run into this problem a lot

Are you trying to achieve spring-like oscillating motion?

yeah, a mass that, when disturbed, oscillates back and forth, where that oscillation decays at some rate I control

but with the additional constraint that I can only work by setting the forces acting on them, not their positions directly

Because if the simulation uses a step like next_y = (e^(-cur_y^2)) * cur_y, where y is the offset from the rest position, and you repeat that, it will not ever oscillate around the 'rest position'. If it starts out with cur_y = 10, say, then the next values of y will just get smaller and smaller, but always positive, and slow down the closer it gets to 0.