i feel like i’m missing 2 things about protocols; 1) if a record implements a protocol, and that record has fields defined in defrecord MyRecord [foo], what’s the difference between using foo and (:foo this) in a protocol function’s implementation? 2) how does a protocol call one of the other functions defined in its own protocol interface? I’m getting compiler warnings about my-protocol-func not defined if attempting to do something like

IMyProtocol
(foo [_ a] ...)
(bar [_ a] (foo _ a)

protocol functions need to be used the same way you would any other function

you look like you might be using the interface generated by the protocol instead of the protocol

they belong to the other namespace

you could also use the method call syntax .foo without namespacing of course, but it’s better to use the protocol function

ahh.. they are defined in the protocols.cljs so you have to protocols/foo in the above example

right

very common beginning mistake with protocols - to think their functions are like methods

(and they are - but not in this aspect)

so the this context is kind of the method context? “invoke my protocol func on this”

it’s the object that the method was called on - and don’t call it _ if you are going to call a function on it

I would say the answer to your first question is "there is no difference use whichever you prefer"

_ is a naming convention that means “I plan on ignoring this, on purpose”

the behavior of this is likely slightly different in clojurescript vs. clojure

although honestly I haven't used a defrecord in 2 years so I may be misremembering something

(this meaning the first argument to something defined inline on a defrecord, deftype, or reify)

I suspect that using the name of the field directly leads to a faster lookup, but if that difference means anything in your code you probably want something more performant than a record anyway

so even if I invoke (protocols/foo this), it still doesnt matter if I refer to the record’s field or the (:foo this) because at that point the context has already changed

what?

the first argument is always going to be the thing you invoked the protocol function

on

(defrecord MyRecord [field]
  IMyProto
  (foo [this a] (do-something field)) <- here shouldnt matter if I use field or (:field this)?
  (bar [this a] (protocols/foo this a)

I just want to make sure I dont get this very subtle bug by implementing a protocol that’s using a field versus a lookup on this, when self-referencing(?) a protocol

field and (:field this) will always be the same thing

i’ve been stabbed in the foot by javascript so many times I’m very paranoid

okay, good to know the context stays the same no matter how it’s invoked

thanks @hiredman @bfabry @noisesmith :thumbsup:

let my_obj = {
  lolGoodLuck(args) {
    let that = this
    function() {
      that.call(this, args)
    }
  }
}
my_obj.lolGoodLuck.apply(youWillNeverGuess)

Got a tough problem if anyone has an answer. Basically I have a large data structure (vector of hashmaps) about 50,000 hashmaps. And I need to pass the data to a Java function, but the hashmap has keyword keywords and those keywords need to be transferred to strings for the java function. Is there a fast way to convert keyword keywords to strings? right now the conversion takes about 2 seconds

Use strings from the start instead of keywords?

You're talking linear time + string manipulation. Probably not a fast operation no matter how you slice it.

name shouldn't be manipulating strings - it should just be getting a field from the keyword

Turning string data into keywords is a bad habit that clojure developers have. Benefit is really only concision, downsides are slow and buggy translation.

(I mean, if you are converting by manipulating strings, use name instead)

Yeah right. Fair enough.

@josh_tackett I just generated 50,000 keywords, at 50 random characters each (using c.s.gen), and both str and name take about <10ms to convert the whole vector from keywords to strings

(defn trunc [s n]
  (subs s 0 (min (count s) n)))

(def kws
  (doall
    (gen/sample
      (gen/fmap
        #(keyword (trunc (name %) 50))
        (gen/keyword))
      50000))

(time (do (doall (map name kws)) nil))
"Elapsed time: 5.684874 msecs"
=> nil
(time (do (doall (map str kws)) nil))
"Elapsed time: 5.781799 msecs"
=> nil

(where gen is clojure.spec.gen.alpha)

@joshjones ya your test doesn’t compare as I am talking about a series of hashmaps with multiple keys in each one

but @potetm your suggestion is what I landed on, so I’ll just change my json decoding to get string keys

oh, so there are many such keywords in each hashmap?

@joshjones correct

how many total?

I bet the map construction when converting is the more expensive part, not the keyword/string part

^^ yep

but avoiding converting avoids both

@lwhorton re: field vs (:field this) -- I asked a while back and Alex said to use field as it will be faster and it's the "correct" way to deal with records /cc @bfabry @hiredman @noisesmith

I'm using boot for my build system. Is there a library to help with the following task. I have a function TRANSLATE, which does .foo -&gt; .clj. I also have a bunch of .foo files. Whenever any of them changes, I want TRANSLATE to be called to generate the corresponding .clj file. Is there a library to handle this for me?

@solve-calc.com This should probably do the trick https://github.com/wkf/hawk

Or, actually, I think boot has that as a built in task

I see now. The core of my problem is just a "watch + notify." Right, there's a boot task. Boot can do this already for me.

hi everyone, i want ask, how create multiple connection database or host in sqlkorma ?

How well would a clojure dev environment work on a Raspberry Pi?

I have two REPL clients connected to the same nrepl and I want them to share a stdout/stderr, is this possible without unix hackery?

nrepl is a network library, it doesn’t share stdio between processes

you’d need some other infrastructure entirely

you could set something up for multicast output to clients, but it would require new middleware on both the client and server sides

hm.. maybe only server side

Thanks! @noisesmith I guess nirvana is not for this world. I'll just do the unix hackery

can anyone explain the difference between event and trigger in FSMs? In particular in context of UML state charts specification. Is it just a java-esque OOP overhead, or is there key semantic difference?

“trigger” is more general, “event” assumes a specific interpretation of how the state machine interacts with an unknown outside world

by unknown I mean “something not specified by the machine itself”

you can of course describe all things as events, but that’s a more specific term, and some semantics prefer to draw a distinction between eg. an event and a start of a timer

can you give an example, where having an event and a trigger would not be "redundant"?

since that can be triggered internally by another part of the machine

maybe I did that already as you were typing? if a change in one part of the machine activates another part of the same machine, that’s a trigger, but not an event because it came from inside the machine itself

so let’s say a parser: if your language rules say “you are now in a closure” that’s a trigger but not an event, if you read a semicolon and that means you end the closure, that is an event that is also a trigger

I have a feeling, that having both events and triggers (which are followed with guards (predicates)) - is somewhat excessive, at least in the clojure/edn/library context

they are different levels of abstraction - an event is a special kind of trigger and most users of fsms differentiate them

definitely implement in terms of triggers first, if you do it right you can build events on top if you need them?

but calling a trigger that is totally internal to the state of the machine an event seems weird (unless you also reify the trigger as some output and re-consume it I guess? I’ve done that for coordination)

I get that there are less/more specific events. what I cannot pin point, is why some would be triggers, not events (or vise versa)

so basically: internal=trigger, external=event? (interna/external to machine, not particular state)

or even: event/type is a trigger, but event is an entire "object"? sort of

no, event is not the general thing, a trigger is the general thing

all things that cause transitions are triggers, period

if you only want one abstraction, it’s a trigger

an event is a special kind of trigger

thank you for the input

@misha it could be that what you really want is event sourcing. That works very nicely with clojure / immutable data.

while a state machine is kind of designed for c or assembly, it’s all about when to do what mutation

if so, yeah, everything should be an event, you have a log of events to consume, and you project various views from the events via a projection (aka fold, aka clojure.core/reductions).

I’m currently building a system around that, and it’s very nice (especially the fact that when I hit a bug I can just dump an excerpt of the log, and replaying that log builds my regression test)

@noisesmith I am trying to reconcile my understanding of the components of: rule based systems, FSMs, and event sourcing, to "solve" single page apps state management for myself. I tried basic event sourcing, but when you have: few audio/video html tags with their own states, some i/o, a bunch of buttons depending on the above, and custom performance-sensitive progress bar – it kind of is not enough, and coordinating all of this is not much easier, than just a bunch of atoms with a page of add-watches connecting them. So i went looking for a better way, or just to improve my understanding of the building blocks.

@misha OK - I suggest checking out petri nets btw because they are async and have a formal provable semantics

those are on my reading list, yes

@misha also the very high level response to that problem is “when event sourcing leads to local state changes, reify the state change by sending it out as a new event and then consuming it”

that way you still have the events as the canonical source of all truth

when you have local state changes that will guide behavior that are not visible in the events, you’ve undermined the event sourcing system because you now have an irreproducible state

it’s actually not event sourced any more

I sort of did that. But having few "a pure state {} depending on side-effectful io/video/audio and vice versa" loops messes things up. So I went for specs to get some vocabulary for "internal/external/pure/io events", etc.

the challenge is: from event sourcing pov: there are like 100 states, but from ui components' pov: 10, and I am looking for a way to manage those 2 "projections"

(basically states vs. https://en.wikipedia.org/wiki/UML_state_machine#Extended_states)

my solution was to base things on a petri net - which have two kinds of things, places and transitions, a transition consumes tokens from 1 or more places and puts tokens into 0 or more places. All canonical state is the content of places (keys in a hash-map, obviously) and transitions are described by predicates on the contents under those keys and an update that removes tokens from N places and places tokens in N places

but yes, I have dealt with that problem you describe in my reagent app

what do tokens represent? "should I run this predicate?"?

tokens are immutable data

the predicate says “given these tokens that currently exist, do I fire?”

and firing consumes some tokens and maybe produces some in other places

it’s like actors without the data hiding

instead of mailboxes they have some places they watch (and anyone else can watch), and instead of sending messages they remove data from one place and maybe put new immutable data in places

so the places are basically like queues?

they aren’t ordered

like an (atom {}), which you take values from or put into?

and you might say “I only fire if I can consume 3 from :a plus one from :b” - eg. that is what assigning work to a worker ends up looking like - you have a token for a worker and a token for the job, you consume both and create a new token representing a pending result

so 10 places (nodes) = 10 atoms?

no, you don’t even need an atom

I put it all in one hash map, but you could eg. represent the whole thing with reductions which would mean each state is another item in the lazy-seq that reductions outputs

(free history!)

or reduce on an atom

or whatever

thats how i designed my deterministic game simulation

@samcf hehe my event / petri based library is called “ludic” and the primary metaphor is playing chess by mail

but really it’s doing a bunch of data transitions based on a petri net model from an event source 😄

(ludic is a super intellectual word describing playfulness)

so you have a list of "workers", and just (while true) apply them on the same {}? and each of those modify it, if "there is enough of particular tokens"

@misha one thing it does is manage workers and tasks, but that’s just because I’m running a computation cluster

if you are in the browser, you don’t need workers - make places / tokens that model your domain

eg. a place could be a dom node and the tokens represent the data driving it… (maybe?)

or maybe better would be a place being a UI state, tokens describing it, and transitions deciding where it should go next

Hi! I have a set containing vectors, e.g. #{[1 2 3]}, and I want to get the first element of the first member of the set. Is there a more idiomatic way to do this than (first (first set)) ?

I'll read your lib's readme first. Did not quite get the analogy yet : )

@hmaurer sets don’t have “first” anything, they are unordered

if you want an implementation-derived item that will change when you change contents in odd ways, sure, you can call ffirst

@noisesmith right; in my case I don’t care about which element of the set gets picked; hopefully it should be a singleton set, or empty set

but don’t count on any particular item coming out

ffirst is exactly what I was looking for; thank you!

@misha I almost regret mentioning my lib - it’s still super young and I don’t think the examples are good yet and it’s still changing fast

just FYI

I only brought it up because of the game thing

@noisesmith I just need lots of input and analogies to straighten my thoughts at this point :)

@misha on that account, this book is very well written, has beautiful illustrations and typography https://www.amazon.com/gp/product/3642332773/ref=oh_aui_detailpage_o04_s00?ie=UTF8&amp;psc=1

(it’s a book about petri nets, since the url doesn’t reveal that)

definitely the most beautiful CS book I own

no kindle edition

thank you. everything was really helpful

np - and keep in mind you might not need the petri net model - you might just want eg. CSP instead (since core.async is right there) - but do think about how well the foo you connect your events to is something that works nicely in the clojure ecosystem

events -> datalog works great too

about that

the bigger picture I keep in mind, is some kind of format, which can help describe system in concise way, so you could see it all at once, to some level of details

like: http://www.thelogbook.com/phosphor/2008/frisky.gif

channels are cool, but when all the plumbing is spread across entire project - it becomes challenging to see the "project mini map". And anything I encountered so far – are either one way graph wiz pngs, or completely new visual-first language.

it was pretty straightforward to make a function that consumed my rules and based on the places they consume from and produce to (fields on the rule record) generate a .dot file for graphviz showing a petri net.

not the precise petri net my code implements (since my code can easily break that abstraction…) but at least a diagram that is helpful

yeah, I saw the .dot support

you also might find Milner' Pi Calc useful https://www.amazon.com/Communicating-Mobile-Systems-Pi-Calculus/dp/0521658691

@mobileink oh nice thanks for reminding me of that

np, thanks for the petri book ref, always wanted to find sth like that!

is there a parallel transduce? say, something like (pmap send-messages!)

Is https://github.com/stuartsierra/component “state of the art” to structure a system in Clojure? Or does anyone have better advice?

I prefer https://github.com/tolitius/mount by far. Simpler, less opinionated, less viral.

mount is just terrible though

could be. I rather don't like component.

@hmaurer check out integrant: https://github.com/weavejester/integrant

😄 well, let me turn my question around then: what would be your preferred way to structure a system to as to make dependency injection / mocking easy?

component

I am new to clojure and about to build my first app

mount 🙂

lol

Integrant 😉

mount is a formalized system of global state, component gets rid of global state

I guess I’ll try all three then

But I might be a touch biased

😄

oh, integrant is your project @weavejester

@hiredman why is mount terrible?

Component is the most used. Integrant is a little new, but YMMV.

yeah, I guess that's the best thing to do: try all 🙂

@weavejester what does integrant do better than mount and component?

mount is based on global state in global atoms

I've done that, it sucked

component turns your system in to another first class value you can pass around, have multiple copies of, etc

@hiredman we've all done all kinds of stuff, I never liked component. No need to argue with : I like it - I don't.

I fear I’ve asked a more contentious question than “should I use VIM or Emacs?”

@hmaurer Compared to Mount, Integrant doesn’t have global state. Compared to Component, Integrant can have dependencies between things that aren’t maps/records.

I feel like Vim and Emacs users can be collectively smug toward users of lesser editors 😉

we know @hiredman doesn't like mount : https://gist.github.com/pandeiro/9a1c8fd431e1b4c78c99

That discussion actually drew my attention to mount, and I like it since. Thanks to @hiredman 🙂

huh, I didn't know there was acopy of that floating around

seems bad, like sticking (def state (atom {})) in every namespace would be

god no

singleton global state is bad and sprinkling clojure on it doesn't make it good

still, thanks for pointing me to mount 😉

actually, I'd love to see good example of not doing global atoms, asking for a friend™

I guess good component example would suffice as well

all the main component projects I have worked on have been closed source apps

Here is the problem with global state: you don’t know beforehand how you will want to use your code later. So, inevitably the system grows to the point where your previous “application” is subsumed in some larger structure, and you have to refactor all the global state out of it. Which is a much bigger pain later.

Read the discussion... it's enlightening

https://github.com/hiredman/songs-of-future-past/blob/master/src/com/manigfeald/sofp.clj is an example of something using component, I don't know that it is good

thank you

it doesn't have any tests, which is where the lack of global state would really shine

I only say this because I went through this before. Component solves a problem I was having, and has been great ever since.

I feel like you can go through this yourself, maybe that is the only way to see it

I would say it is a classic easy/simple split, component is way simpler (https://gist.github.com/hiredman/075b45eaeb01e4b526ce6f8854685487 implements all the functionality of component in 30 lines, but lacks refinement), but mount is going to be easier because using globals is always easier for a few months

I think of it as an “easier now”/“easier later” divide

Global state is easy now. You don’t have to learn anything and it doesn’t take work to set up

Going the 'simpler' and 'easier' way, are we?

Right, it may be easier, and if it solves the problem, why make it more difficult? - What is the problem you want to solve? This may be the first question to @hmaurer

But there will come a day when you are screwed

Having a viral framework, I never liked that. Component is more a framework - I will be screwed as well

@kurt-o-sys Agreed. @hmaurer If you are trying to learn Clojure, just use a global atom

Have used enough frameworks, they always hit you in the face as well... and hard 🙂

I don’t really want to use a global state atom. While I am new to clojure I’ve been interested in functional programming for quite a while; if there are ways to avoid global state I rather do so

But I’ll try out mount either way

@kurt-o-sys We disagree in general, it is okay

I might learn some valuable lessons

@hmaurer That is good context. In that case I think you will appreciate component

fwiw, there is a yurt for mount https://github.com/tolitius/yurt

Multiple brand new local Yurts with components can be created and passed down to the application / REPL to be used simultaneously in the same Clojure runtime for fun and profit.

Exactly - check what works out for you.

integrant seems ok, I haven't looked at in depth, but it looks like it uses multimethods for dispatch, which I've done with component before, but is annoying if you want to create an anonymous sort of mock of something in a test

@hmaurer Once you understand it, it is not as bad as people make it out to be

A global state atom also sounds a bit messy for mocking

It is a conceptual hurdle

not a technical one

I mean, you could set the global state atom before runing your tests with the mock dependency

but it sounds a bit dirty

@hmaurer the beating heart of mount https://github.com/tolitius/mount/blob/master/src/mount/core.cljc#L12-L16

@spangler right... one prefers frameworks, the other doesn't. Fine with me 🙂.

Global state atom can be bad, of course. That's why mount manages it, so you don't have to.

I would call component more of a pattern. It is not doing much for you, most of it is explicit

Anyway, we'll never agree on that part - that discussion was pretty clear about how it's not that different from component (passing in state everywhere)

It is a pattern of state access, treating state as a value

@spangler right... it does not do much... I like that 🙂

Basically, it is the functional way to do things: you have to pass everything in

yes, that's a dogmatic reason. I prefer pragmatism in many cases.

Is there a good blog/book/resource somewhere on clojure ways of doing things? (i am already familiar with “programming clojure” and “the joy of clojure”)

I've heard good things of http://www.braveclojure.com/

heh, I went to Mount after a couple years of Component straitjacket. In a bigger team I’d use Component though 🙂

clojure does have state management constructs because you don't pass everything in. There's a reason why clojure isn't dogmatic on FP.

https://leanpub.com/elementsofclojure isn’t finished but has some interesting ideas. It’s not a general purpose programming book, though. I think the first chapter on naming is free.

As someone who initially went down a Mount-like path when building a system and has since switched to Component, I'll "vote" for @hiredman's position here that global state is a terrible idea.

It is a terrible idea in general, right. The dogmatic reason. I can understand it.

But having a viral framework has hit me many times, including component.

We're still feeling the pain of the global state approach as we piecemeal migrate away from it (by using Component instead but having its start/`stop` functions keep the legacy global state in sync until we can replace it).

That's why I prefer mount - pragmatism, and as long as you manage state, it's ok.

single global atom is the rallying cry for frontend projects lately

🙂

@hmaurer as you can tell from this thread, there is always More Than One Way to Do It. Master the basics first, then you'll see just how true that is!

lol true!

Component is not a "viral framework". Functions need to be based stuff as arguments, not reach out to global state for it.

Haha, I am glad it sparked a discussion though. It would have been quite boring if someone linked me a lib and 5 people thumbed up

Once you start using component, it's hard not to use it everywhere in your code base.

@samcf

So well, I call that viral (inside the code base).

@samcf I wouldn't be surprised if that is the primary split front end / back end on mount / component

You do it 'the component way' or not. There's nothing in between... using component.

I think it is more about providing each part of your system the minimal amount of information it needs to do its job. That way you can decompose and rearrange it later. Which at some point will become very important.

global state creates interdependence, which is weakness

Hate to make an argument by authority, but it's really not insignificant that some of the most veteran clojure developers (@hiredman / @seancorfield ) favor component. Personally I think mount teaches new clojure users bad habits.

Same with mount, honestly. Check that discussion I posted above, it's really all not that different.

s/mount/global state patterns/

@kurt-o-sys any given function just needs to be passed what it needs -- not the whole system -- and that's just functional cleanliness. You initialize all your resources at application startup, put them in a map, pass the relevant bits down the call chain. Component just formalizes that and manages dependencies for you.

Same with mount, really, if you like so.

@ghadi - even though I prefer Mount - I agree 🙂 Mount should only be allowed once you spent a year with Component

@dm3 🙂

Perhaps the pain level with Mount doesn't show up until you have a large enough system? Just like global state only causes you pain after a certain point?

The mount readme describing component is disingenuous https://github.com/tolitius/mount/blob/master/doc/differences-from-component.md#differences-from-component

@seancorfield it’s probably true. In my case I’ve avoided building large applications (modules). I just have many of them.

We have about 60,000 lines of Clojure right now...

I have half that, but I’m the only dev

LOC - so?

@dm3 I kind of fear your codebase ; )

you should 🙂

Sweet, your glyphs and wards are working

anyway, as said before, one prefers dogmatic, other prefer pragmatism. One prefers frameworks, other prefer libs/patterns. One likes pink, the other blue. Whatever 🙂

(some ran away from component, others ran away from mount, so maybe we all should try integrant and decide it's not a silver bullet either 🙂 )

lol - because someone has an opinion? Nice.

Like I say, hard lessons learned building a system the "easy" way with Mount-like managed state, instead of the "simple" way with Component-like managed dependencies.

zzzzz. clojurians having another vigorous debate/ disagreement without calling each other names. wtf is wrong with you people?! 😉

@mobileink I dunno, can't we just hate each other's software without hating each other?

(hating your own software is of course also acceptable)

hate the code, not the coder!

anyway that was a lame attempt at irony - the clojure community is extraordinarily irenic. (look, i made a pun! whee!)

"hate a la carte" joke

@mobileink Online peace is a noble goal

did i just kill a discussion? ouch.

Interesting discussion. At my work we use mount (mount.lite actually), but I always liked the IoC-pattern in OO, which I miss doing mount. It is nice that you do not have to pass state as parameters everywhere, and if you want to mock a state you can substitute state for a mock implementation. BUT I miss having a composition root responsible for composing modules, and seeing that you have to refactor because a module takes too many constructor parameters.

@hmaurer when you looking at mount, besides the docs, these little example apps may help you to see how it could be used: https://github.com/tolitius/stater

If you want to evaluate mount/component/integrant, I’d recommend starting by just reading them

they’re all in the 300-500 LoC range

I mean there are things you can only learn by using them in a large project for a long time, or talking to someone who has, but I think reading them is a reasonable starting point

Aaand don’t forget the new-new kid on the block: deferst: https://github.com/employeerepublic/deferst

@weavejester Out of curiosity, why did you make the choice of using multimethods for Integrant?

It seems to me (as a clojure beginner) that it introduces a form of global that makes stubbing a bit harder

e.g. wouldn’t it be nicer to pass a second argument to ig/init: a map from keys to implementations?

I am sure you had a good reason for using multimethods and not the approach I’m suggesting, but I would like to understand it

@weavejester is it related to hot-reloading?

do clojure files have to have a namespace?

and if so, should tooling not assume that there will be a namespace form at the top?

they don't

and you can put other things before the namespace

(the ns form)

ok

never really know where to go to find the hard requirements on these things so thanks for the info

it is super common to have the ns form be the first thing, so some tooling does assume it

ok. i was not positive if it was convention or spec

so some tooling requires it, but clojure does not

well, if possible, i'd like to conform to clojure requirements and not some subset

there were some namespace cache changes in CIDER that seems to affect files without a ns form so wanted to see what the requirements were. thanks a bunch