the fundamental thing that react does is provide a way to re-render when your data changes - reagent engages with that directly

your code should avoid mutating state, but it should render a form using data that could update (and you can define a form to re-render when that data updates)

So how does that work? If you need to mutate state, how do you avoid mutating state? I'm sorry if I'm being confusing, I'm a little new to this.

I intentionally say "avoid" instead of don't - it's something we intentionally minimize but can't eliminate

OK. Thanks for clarifying.

most changes to state are going to come from the browser: some user input changes something, your app has a defined way to react

so there's inherently a tracking of state in each widget that's wired into react - that should be mostly hidden from your code

what your code does is access the current value out of app state from inside a component, and when that happens the react engine will know to come back and re-render that component if the state it reads from changes

thus instead of a bunch of commands saying "re-render this, re-render its children" or whatever, the framework can decide what needs rendering based on how you define and use your data

that's the big picture tl;dr at least

So only make things mutable if they directly involve what's being put on the screen?

I think I get the idea.

yeah - that's pretty much it - you can actually treat the mutables as immutable args to your rendering function - and reagent will make sure your rendering function is called again if the args change

so it's a lot like data flow if you've heard of that

OK. Thanks @U051SS2EU.

There's a good talk on this: https://www.youtube.com/watch?v=vK1DazRK_a0 where the mutation progressively gets minimized throughout the talk

I dunno the context, but if you are coming from scheme, it is important to know in clojure def always creates a global "top level" definition regardless of the scope it is in

If you need a named fn inside your form, there is a let-fn

does the clojure community have opinions about (if pred x) versus (when pred x)? should when be used if there's no else?

or should it merely be used instead of (if (do

it is a divisive issue, at my last job you would bring that up if you wanted a break from arguing about git branching

I like when for any single branched if, but some common lisp style guides (which a lot of cues for clojure style came from) suggest only using when if there are side effects

to me, when means single branched if. i had no idea about the side effects.

the reasoning goes when has an implicit do, and do is for side effects

i had no idea do is for side effects! I thought it was just for combining multiple expressions... which i guess you only need if you're doing side-effects?

correct

you should not. only create a state for something low level and inherently stateful: i.e. I/O, queues/topics, connections, etc. while it might feel "uncomfortable" at first it will encourage you to learn to design and keep your functions stateless. for example a function that needs an "atom with a timestamp": it can take it as an argument or destructure a timestamp from configuration state that is passed in or, most likely, it could create one inside itself in a let block, use it and forget it. it would depend on a business use case of course.

Can you paste a link to the guide?

https://clojurescript.org/guides/quick-start

add repl-opts launch-browser false seems solve the problem

for figwheel add open-url false solve the issue too.

If you are new to ClojureScript, I recommend jumping straight to shadow-cljs. I am new too and I find it super easy. It just works.

I will try shadow cljs another time.

surely, send the code 🙂

(ns the-divine-cheese-code.visualization.svg)

(defn latlng->point
  "Convert lat/lng map to comma-separated string" 
  [latlng]
  (str (:lat latlng) "," (:lng latlng)))

(defn points
  [locations]
  (clojure.string/join " " (map latlng->point locations)))

and this is in my core.clj

(ns the-divine-cheese-code.core)
;; Ensure that the SVG code is evaluated
(require 'the-divine-cheese-code.visualization.svg)
;; Refer the namespace so that you don't have to use the 
;; fully qualified name to reference svg functions
(refer 'the-divine-cheese-code.visualization.svg)

can you share the exact error?

and maybe you have the code on github?

https://github.com/gabbigum/temp-repo

it is filenotfound exception

move your visualization dir to src

so you’d have dir structure:

src/
  core.clj
  visualization/
    svg.clj

it should do the trick

Thanks very much!

It worked

no worries

glad it works

no - it's not, some->> is like ->> but stops if something is nil

user=> (some->> nil (+ 1))
nil

there's little relationship between some some? and some-> / some->>

(some #{7} (range)) => 7 , but (some->> (range) (filter #(= 7 %))) never returns.

they are totally different functions, yes

ok, thanks

you could try (comp #(.getTime %) :date) instead of :date to make it use a numeric type

getTime gets the epoch ms

compare should be working though

(ins)user=> (java.util.Date. 0)
#inst "1970-01-01T00:00:00.000-00:00"
(ins)user=> (java.util.Date. 1)
#inst "1970-01-01T00:00:00.001-00:00"
(ins)user=> (compare *2 *1)
-1

Ah, totaly forgot about compare! Thank you so much for the help, did just the trick!

I guess ill have to go read up on some javadocs for more on how to handle the insts

the #inst notation is clojure specific, there's more than one type that prints that way

but if you consume a #inst tagged object, you'll get a java.util.Date

After some more testing they actually seem equal in performance

Hi, I was using criterium/quick-bench . But I made a mistake in my test. Looks like these two cases are pretty much equal in performance

ruby too iirc

Why the sudden hot take on Python 🙃? PS: I'm not offended, I'm usually the one doing this in my friend circle 😛

I just wrote some Python this afternoon 🙂 I think they are conflating promises that a specific map impl makes with the fundamentals of associative memory

(bad for the ecosystem, IMHO)

both w.r.t. beginners' mental models, and code found in the wild

I think the problem they ran into was that, in practice, beginners relied on the implementation’s order no matter what it was

so they felt that not having an order at all was priming beginners for nasty mysterious bugs

meh, beginners are going to abuse anything until they learn better, just like in clojure some beginners abuse records when they should be using maps

well, this is one reason that python is a better language for beginners than clojure: they think about different traps beginners can get into, and if one of them is a serious trap that doesn’t fail fast, they fix it

that's very debateable. it also teaches a habit of expecting maps to have an order which will burn them in any language where they opted not to take the performance hit (pretty much everything except ruby and python I think)

can you generate the html serverside?

is the full table visible on the screen? you might be able to only generate the part of the table that will be visible on screen and generate the non visible part in the background

I am not sure if I could do the rendering serverside. But would that help with the laggy tab switching? I need to look into only showing the visible parts of the table. Not sure how tricky that will be though

it should make the tab switching faster, but might slow down the page load

although, if your content is gzipped, then it might not be that big a slowdown

and there might be speedup opportunities depending on how you’re generating the html on the tab switch

Well currently it builds everything and then it dynamically hides everything but the active tab's content. I guess am not understanding how building the html serverside would help.

so the tab switch is still slow even if the html is already built?

Yes, exactly

that must be a ton of html.

Not as slow as if I was building each tab from scratch but def noticeably slow.

yea, I would look into chunking the table into smaller pieces

It is. Each tab might have a table with 10K-30K cells

yup, that would do 🙂

I remember watching a tech talk about someone who had a similar problem. trying to see if I can find it

maybe it was something like https://www.datatables.net/extensions/scroller/examples/initialisation/large_js_source.html

Looks interesting gonna take a look

UX wise, what kind of data is in a table with 10-30k cells such that having a user scroll through that much stuff is the optimal way to present information?

In our apps at my job, we cap all tables to a 500 record limit. No paging controls either. We provide filters and other controls to narrow down whatever it is the user needs.

I know this approach doesn't necessarily work for all scenarios (like "infinite scrollers" a la Facebook where you're just browsing, not lifting something specific), but it definitely works for our apps. I've always disliked "pagers", and huuuuuuge (yet finite) lists/tables. Narrow down what you want, no human can digest 30k cells of data in a single shot.

Its an HTML representation of an excel workbook. Users upload an excel workbook that can contain multiple sheets. We then extract information cell-by-cell including cell-styling, content, formatting, etc and build a data-structure that looks more or less like this

{"sheet-name" {[1 4] {:backGroundColor "#000"}} 

I believe there is a better way to create a projection of that workbook but this is how it was built so I am working with this set up for now until we get time to refactor. lol