Fork me on GitHub
#clojure-norway
<
2024-04-25
>
teodorlu05:04:01

Morn! Hvilke clojure.core-vars bruker du mest? Jeg bruker tydeligvis mye defn, let, str, ->, ->> og map (se vedlagt statistikk).

👀 1
cjohansen06:04:32

([[clojure.core defn] 75]
 [[clojure.core let] 34]
 [[clojure.core def] 31]
 [[clojure.core ->] 29]
 [[clojure.core if] 25]
 [[clojure.core .] 23]
 [[clojure.core assoc] 21]
 [[clojure.core ->>] 20]
 [[clojure.core fn] 18]
 [[clojure.core fn*] 15]
 [[clojure.core map] 15]
 [[clojure.core when] 14]
 [[clojure.core defmethod] 12]
 [[clojure.core read-string] 11]
 [[clojure.core update] 10]
 [[clojure.core cond->] 10]
 [[clojure.core str] 9]
 [[clojure.core first] 9]
 [[clojure.core try] 9]
 [[clojure.core inc] 9]
 [[clojure.core ex-info] 8]
 [[clojure.core comment] 8]
 [[clojure.core for] 8]
 [[clojure.core =] 8]
 [[clojure.core throw] 8]
 [[clojure.core when-let] 7]
 [[clojure.core not-empty] 7]
 [[clojure.core nil?] 7]
 [[clojure.core mapcat] 6]
 [[clojure.core swap!] 6]
 [[clojure.core slurp] 6]
 [[clojure.core cond] 6]
 [[clojure.core seq] 5]
 [[clojure.core conj] 5]
 [[clojure.core pr-str] 5]
 [[clojure.core set] 5]
 [[clojure.core some] 5]
 [[clojure.core filter] 4]
 [[clojure.core into] 4]
 [[clojure.core when-not] 4]
 [[clojure.core <] 4]
 [[clojure.core assoc-in] 4]
 [[clojure.core recur] 4]
 [[clojure.core -] 3]
 [[clojure.core case] 3]
 [[clojure.core if-let] 3]
 [[clojure.core parse-long] 3]
 [[clojure.core re-find] 3]
 [[clojure.core make-array] 3]
 [[clojure.core keyword] 3]
 [[clojure.core or] 3]
 [[clojure.core and] 3]
 [[clojure.core loop] 3]
 [[clojure.core select-keys] 3]
 [[clojure.core not] 3]
 [[clojure.core merge] 2]
 [[clojure.core range] 2]
 [[clojure.core juxt] 2]
 [[clojure.core reduce] 2]
 [[clojure.core println] 2]
 [[clojure.core keyword?] 2]
 [[clojure.core name] 2]
 [[clojure.core parse-double] 2]
 [[clojure.core drop] 2]
 [[clojure.core concat] 2]
 [[clojure.core doseq] 2]
 [[clojure.core sort-by] 2]
 [[clojure.core comp] 2]
 [[clojure.core +] 2]
 [[clojure.core some->] 2]
 [[clojure.core some->>] 2]
 [[clojure.core remove] 2]
 [[clojure.core nth] 2]
 [[clojure.core spit] 1]
 [[clojure.core with-open] 1]
 [[clojure.core /] 1]
 [[clojure.core sort] 1]
 [[clojure.core string?] 1]
 [[clojure.core atom] 1]
 [[clojure.core keep] 1]
 [[clojure.core namespace] 1]
 [[clojure.core format] 1]
 [[clojure.core min] 1]
 [[clojure.core map-indexed] 1]
 [[clojure.core int] 1]
 [[clojure.core random-uuid] 1]
 [[clojure.core max] 1]
 [[clojure.core get] 1]
 [[clojure.core defmacro] 1]
 [[clojure.core subs] 1]
 [[clojure.core *] 1]
 [[clojure.core ex-data] 1]
 [[clojure.core take] 1]
 [[clojure.core not=] 1])
Morsomt! Dette er fra det nye systemet vi bygger. Vi har i all hovedsak jobbet med det imperative skallet, så her er feks throw og ex-info høyt oppe 😄

👀 1
cjohansen06:04:12

Matvaretabellen:

([[clojure.core defn] 316]
 [[clojure.core let] 148]
 [[clojure.core ->>] 142]
 [[clojure.core map] 100]
 [[clojure.core fn*] 87]
 [[clojure.core ->] 81]
 [[clojure.core if] 77]
 [[clojure.core str] 67]
 [[clojure.core for] 65]
 [[clojure.core def] 62]
 [[clojure.core into] 49]
 [[clojure.core get-in] 48]
 [[clojure.core fn] 48]
 [[clojure.core assoc] 43]
 [[clojure.core comp] 41]
 [[clojure.core .] 37]
 [[clojure.core when] 36]
 [[clojure.core count] 34]
 [[clojure.core first] 34]
 [[clojure.core or] 34]
 [[clojure.core get] 32]
 [[clojure.core remove] 31]
 [[clojure.core update] 29]
 [[clojure.core mapcat] 26]
 [[clojure.core sort-by] 26]
 [[clojure.core when-let] 25]
 [[clojure.core =] 25]
 [[clojure.core nil?] 25]
 [[clojure.core filter] 24]
 [[clojure.core cond->] 24]
 [[clojure.core set] 24]
 [[clojure.core conj] 21]
 [[clojure.core seq] 20]
 [[clojure.core second] 19]
 [[clojure.core concat] 17]
 [[clojure.core some->] 17]
 [[clojure.core <] 16]
 [[clojure.core apply] 15]
 [[clojure.core empty?] 14]
 [[clojure.core name] 14]
 [[clojure.core list] 14]
 [[clojure.core cond] 14]
 [[clojure.core /] 13]
 [[clojure.core dissoc] 13]
 [[clojure.core re-find] 13]
 [[clojure.core nth] 12]
 [[clojure.core merge] 11]
 [[clojure.core juxt] 11]
 [[clojure.core comment] 11]
 [[clojure.core select-keys] 11]
 [[clojure.core case] 10]
 [[clojure.core if-let] 10]
 [[clojure.core identity] 10]
 [[clojure.core parse-long] 10]
 [[clojure.core +] 10]
 [[clojure.core vector] 10]
 [[clojure.core reduce] 9]
 [[clojure.core when-not] 9]
 [[clojure.core keep] 9]
 [[clojure.core slurp] 9]
 [[clojure.core group-by] 8]
 [[clojure.core -] 7]
 [[clojure.core map?] 7]
 [[clojure.core range] 7]
 [[clojure.core ex-info] 7]
 [[clojure.core update-vals] 7]
 [[clojure.core throw] 7]
 [[clojure.core recur] 7]
 [[clojure.core not] 7]
 [[clojure.core last] 6]
 [[clojure.core doseq] 6]
 [[clojure.core int] 6]
 [[clojure.core not-empty] 6]
 [[clojure.core vals] 6]
 [[clojure.core vec] 5]
 [[clojure.core drop] 5]
 [[clojure.core partial] 5]
 [[clojure.core read-string] 5]
 [[clojure.core coll?] 5]
 [[clojure.core and] 5]
 [[clojure.core *] 5]
 [[clojure.core take] 5]
 [[clojure.core hash] 4]
 [[clojure.core dec] 4]
 [[clojure.core cond->>] 4]
 [[clojure.core re-seq] 4]
 [[clojure.core some->>] 4]
 [[clojure.core keys] 4]
 [[clojure.core loop] 4]
 [[clojure.core next] 4]
 [[clojure.core try] 4]
 [[clojure.core cons] 4]
 [[clojure.core not=] 4]
 [[clojure.core inc] 4]
 [[clojure.core val] 3]
 [[clojure.core sort] 3]
 [[clojure.core string?] 3]
 [[clojure.core re-pattern] 3]
 [[clojure.core odd?] 3]
 [[clojure.core repeat] 3]
 [[clojure.core take-while] 3]
 [[clojure.core parse-double] 3]
 [[clojure.core pr-str] 3]
 [[clojure.core map-indexed] 3]
 [[clojure.core frequencies] 3]
 [[clojure.core keyword] 3]
 [[clojure.core tree-seq] 3]
 [[clojure.core key] 3]
 [[clojure.core quot] 3]
 [[clojure.core zero?] 2]
 [[clojure.core reverse] 2]
 [[clojure.core contains?] 2]
 [[clojure.core interpose] 2]
 [[clojure.core set?] 2]
 [[clojure.core partition-by] 2]
 [[clojure.core min] 2]
 [[clojure.core type] 2]
 [[clojure.core abs] 2]
 [[clojure.core boolean] 2]
 [[clojure.core assoc-in] 2]
 [[clojure.core disj] 2]
 [[clojure.core butlast] 2]
 [[clojure.core with-open] 1]
 [[clojure.core complement] 1]
 [[clojure.core map-entry?] 1]
 [[clojure.core take-last] 1]
 [[clojure.core swap!] 1]
 [[clojure.core deref] 1]
 [[clojure.core atom] 1]
 [[clojure.core keyword?] 1]
 [[clojure.core vector?] 1]
 [[clojure.core format] 1]
 [[clojure.core mod] 1]
 [[clojure.core zipmap] 1]
 [[clojure.core prn] 1]
 [[clojure.core seq?] 1]
 [[clojure.core mapv] 1]
 [[clojure.core instance?] 1]
 [[clojure.core defonce] 1]
 [[clojure.core set!] 1]
 [[clojure.core update-in] 1]
 [[clojure.core max] 1]
 [[clojure.core constantly] 1]
 [[clojure.core partition-all] 1]
 [[clojure.core <=] 1]
 [[clojure.core subs] 1]
 [[clojure.core *print-namespace-maps*] 1]
 [[clojure.core partition] 1]
 [[clojure.core double] 1]
 [[clojure.core drop-last] 1])

cjohansen06:04:24

fn* kommer høyt opp på begge - den bruker vi ikke for hånd

pez06:04:55

->> ligger høyt oppe på begge listene dine, @U9MKYDN4Q 😄

teodorlu06:04:13

> ``` [[clojure.core update] 10] > [[clojure.core cond->] 10] > [[clojure.core str] 9]``` Jeg visste det! jeg visste det! Du bruker masse `cond->` ! :smile_cat: :catjam:

teodorlu06:04:44

nå er det bare å finlese listene dine og finne ut at hvilke funksjoner jeg ikke bruker 😈

teodorlu06:04:44

>

[[clojure.core defmethod] 12]
Bruker dere defmethod til noe annet enn integrant?

Fredrik Meyer06:04:37

Gøy! Her er fra generativ kunst-repoet mitt

([[clojure.core defn] 244]
 [[clojure.core +] 148]
 [[clojure.core let] 140]
 [[clojure.core /] 121]
 [[clojure.core *] 119]
 [[clojure.core def] 87]
 [[clojure.core -] 85]
 [[clojure.core if] 54]
 [[clojure.core fn] 52]
 [[clojure.core range] 48]
 [[clojure.core doseq] 48]
 [[clojure.core println] 40]
 [[clojure.core <] 37]
 [[clojure.core recur] 35]
 [[clojure.core comment] 33]
 [[clojure.core conj] 33]
 [[clojure.core >] 24]
 [[clojure.core when] 22]
 [[clojure.core map] 22]
 [[clojure.core first] 21]
 [[clojure.core assoc] 20]
 [[clojure.core str] 20]
 [[clojure.core inc] 20]
 [[clojure.core update] 19]
 [[clojure.core loop] 19]
 [[clojure.core ->] 18]
 [[clojure.core and] 17]
 [[clojure.core time] 16]
 [[clojure.core =] 16]
 [[clojure.core .] 15]
 [[clojure.core fn*] 15]
 [[clojure.core count] 14]
 [[clojure.core apply] 14]
 [[clojure.core cond] 12]
 [[clojure.core rand] 12]
 [[clojure.core identity] 11]
 [[clojure.core do] 11]
 [[clojure.core <=] 11]
 [[clojure.core nil?] 11]
 [[clojure.core pop] 10]
 [[clojure.core ->>] 10]
 [[clojure.core for] 9]
 [[clojure.core with-meta] 9]
 [[clojure.core get] 8]
 [[clojure.core or] 8]
 [[clojure.core throw] 8]
 [[clojure.core not] 8]
 [[clojure.core filter] 7]
 [[clojure.core into] 7]
 [[clojure.core meta] 7]
 [[clojure.core concat] 7]
 [[clojure.core dec] 7]
 [[clojure.core partition] 7]
 [[clojure.core >=] 7]
 [[clojure.core empty?] 6]
 [[clojure.core defn-] 6]
 [[clojure.core rest] 6]
 [[clojure.core number?] 5]
 [[clojure.core seq] 5]
 [[clojure.core dotimes] 5]
 [[clojure.core get-in] 5]
 [[clojure.core defrecord] 5]
 [[clojure.core abs] 5]
 [[clojure.core aget] 5]
 [[clojure.core case] 4]
 [[clojure.core hash] 4]
 [[clojure.core reduce] 4]
 [[clojure.core when-not] 4]
 [[clojure.core peek] 4]
 [[clojure.core instance?] 4]
 [[clojure.core mod] 3]
 [[clojure.core rand-nth] 3]
 [[clojure.core defprotocol] 3]
 [[clojure.core conj!] 3]
 [[clojure.core require] 3]
 [[clojure.core take] 3]
 [[clojure.core use] 3]
 [[clojure.core second] 3]
 [[clojure.core mapcat] 2]
 [[clojure.core reset!] 2]
 [[clojure.core zero?] 2]
 [[clojure.core letfn] 2]
 [[clojure.core atom] 2]
 [[clojure.core class] 2]
 [[clojure.core deftype] 2]
 [[clojure.core if-let] 2]
 [[clojure.core print-dup] 2]
 [[clojure.core rand-int] 2]
 [[clojure.core identical?] 2]
 [[clojure.core some?] 2]
 [[clojure.core list] 2]
 [[clojure.core min] 2]
 [[clojure.core update-in] 2]
 [[clojure.core defmethod] 2]
 [[clojure.core boolean] 2]
 [[clojure.core assoc-in] 2]
 [[clojure.core seqable?] 2]
 [[clojure.core next] 2]
 [[clojure.core transduce] 1]
 [[clojure.core contains?] 1]
 [[clojure.core when-let] 1]
 [[clojure.core print] 1]
 [[clojure.core print-method] 1]
 [[clojure.core compare] 1]
 [[clojure.core vec] 1]
 [[clojure.core group-by] 1]
 [[clojure.core repeatedly] 1]
 [[clojure.core iterate] 1]
 [[clojure.core shuffle] 1]
 [[clojure.core persistent!] 1]
 [[clojure.core assert] 1]
 [[clojure.core min-key] 1]
 [[clojure.core gensym] 1]
 [[clojure.core int] 1]
 [[clojure.core extend-type] 1]
 [[clojure.core comp] 1]
 [[clojure.core not-empty] 1]
 [[clojure.core sequential?] 1]
 [[clojure.core some] 1]
 [[clojure.core symbol] 1]
 [[clojure.core transient] 1]
 [[clojure.core sorted-set-by] 1]
 [[clojure.core prefer-method] 1]
 [[clojure.core vector] 1]
 [[clojure.core to-array-2d] 1]
 [[clojure.core nth] 1]
 [[clojure.core not=] 1])

1
cjohansen06:04:47

12 defmethod er nok 6x opp/ned integrant states

pez06:04:10

([[clojure.core throw] 2]
 [[clojure.core defmacro] 1]
 [[clojure.core with-meta] 1]
 [[clojure.core fn] 1]
 [[clojure.core mapv] 1])

cjohansen06:04:20

@UA277415W Masse matematikk! Årntlig programmering 😄

teodorlu06:04:41

i alle dager @U0ETXRFEW, hva er det du driver med i det prosjektet? 😄 Bare metaprogrammering?

cjohansen06:04:57

2:1 ratio på throw:funksjoner virker... feil

😄 1
teodorlu07:04:26

>

[[clojure.core range] 48]
@UA277415W spennende! jeg kan liksom gjette at man kan starte med mye (range) for å lage geometri.

cjohansen07:04:15

([[clojure.core defn] 73]
 [[clojure.core let] 71]
 [[clojure.core if] 53]
 [[clojure.core defmacro] 38]
 [[clojure.core fn] 33]
 [[clojure.core when] 30]
 [[clojure.core next] 30]
 [[clojure.core fn*] 25]
 [[clojure.core =] 25]
 [[clojure.core .] 24]
 [[clojure.core unchecked-inc-int] 23]
 [[clojure.core update] 23]
 [[clojure.core ->] 23]
 [[clojure.core conj!] 22]
 [[clojure.core or] 22]
 [[clojure.core conj] 21]
 [[clojure.core recur] 21]
 [[clojure.core ->>] 20]
 [[clojure.core def] 20]
 [[clojure.core and] 19]
 [[clojure.core swap!] 18]
 [[clojure.core assoc] 17]
 [[clojure.core cond] 16]
 [[clojure.core cond->] 15]
 [[clojure.core first] 15]
 [[clojure.core nil?] 15]
 [[clojure.core str] 13]
 [[clojure.core atom] 12]
 [[clojure.core keys] 12]
 [[clojure.core <] 11]
 [[clojure.core if-let] 11]
 [[clojure.core name] 11]
 [[clojure.core run!] 11]
 [[clojure.core remove] 11]
 [[clojure.core not] 11]
 [[clojure.core when-let] 10]
 [[clojure.core seq] 9]
 [[clojure.core set] 9]
 [[clojure.core deref] 8]
 [[clojure.core persistent!] 8]
 [[clojure.core nth] 8]
 [[clojure.core string?] 7]
 [[clojure.core unchecked-dec-int] 7]
 [[clojure.core +] 7]
 [[clojure.core reduce] 6]
 [[clojure.core vec] 6]
 [[clojure.core dissoc] 6]
 [[clojure.core do] 6]
 [[clojure.core vswap!] 6]
 [[clojure.core transient] 6]
 [[clojure.core throw] 6]
 [[clojure.core count] 5]
 [[clojure.core into] 5]
 [[clojure.core drop] 5]
 [[clojure.core concat] 5]
 [[clojure.core loop] 5]
 [[clojure.core not=] 5]
 [[clojure.core inc] 5]
 [[clojure.core filter] 4]
 [[clojure.core when-not] 4]
 [[clojure.core keyword?] 4]
 [[clojure.core map] 4]
 [[clojure.core comp] 4]
 [[clojure.core keyword] 4]
 [[clojure.core assoc-in] 4]
 [[clojure.core volatile!] 4]
 [[clojure.core take] 4]
 [[clojure.core reset!] 3]
 [[clojure.core merge] 3]
 [[clojure.core unchecked-add-int] 3]
 [[clojure.core ex-info] 3]
 [[clojure.core contains?] 3]
 [[clojure.core keep] 3]
 [[clojure.core meta] 3]
 [[clojure.core pr-str] 3]
 [[clojure.core rest] 3]
 [[clojure.core some->] 3]
 [[clojure.core <=] 3]
 [[clojure.core aget] 3]
 [[clojure.core with-meta] 3]
 [[clojure.core fn?] 2]
 [[clojure.core val] 2]
 [[clojure.core case] 2]
 [[clojure.core map?] 2]
 [[clojure.core range] 2]
 [[clojure.core pos?] 2]
 [[clojure.core namespace] 2]
 [[clojure.core ifn?] 2]
 [[clojure.core println] 2]
 [[clojure.core add-watch] 2]
 [[clojure.core mapv] 2]
 [[clojure.core time] 2]
 [[clojure.core doseq] 2]
 [[clojure.core declare] 2]
 [[clojure.core aset] 2]
 [[clojure.core remove-watch] 2]
 [[clojure.core not-empty] 2]
 [[clojure.core get] 2]
 [[clojure.core boolean] 2]
 [[clojure.core disj] 2]
 [[clojure.core second] 2]
 [[clojure.core symbol?] 1]
 [[clojure.core number?] 1]
 [[clojure.core get-in] 1]
 [[clojure.core empty?] 1]
 [[clojure.core map-entry?] 1]
 [[clojure.core parse-long] 1]
 [[clojure.core vector?] 1]
 [[clojure.core comment] 1]
 [[clojure.core doto] 1]
 [[clojure.core parse-double] 1]
 [[clojure.core seq?] 1]
 [[clojure.core instance?] 1]
 [[clojure.core unchecked-int] 1]
 [[clojure.core max] 1]
 [[clojure.core defprotocol] 1]
 [[clojure.core re-seq] 1]
 [[clojure.core key] 1]
 [[clojure.core coll?] 1]
 [[clojure.core *] 1]
 [[clojure.core with-out-str] 1])
Replicant. Mye makroer 😄

pez07:04:40

Visste ikke at jeg er en throw-kodere.

Fredrik Meyer07:04:40

@U3X7174KS @U9MKYDN4Q Føler Clojure passer veldig godt til meg med matematisk bakgrunn - veldig lett å resonnere om hva et uttrykk evaluerer til. (har havnet i en del (unødvendige...) rabbit holes om optimalisering også, hehe).

👍 1
slipset07:04:25

meh

erik@keep ardoq-api % clj-kondo --lint src --config '{:analysis true :output {:format :edn}}' | bb -e '(def ana (edn/read-string (slurp *in*))) (prn (->> ana :analysis :var-usages (filter #(= (:to %) (symbol "babashka.fs")))))' | jet
[clj-kondo] Auto-loading config path: rewrite-clj/rewrite-clj
[clj-kondo] Auto-loading config path: com.github.seancorfield/next.jdbc
[clj-kondo] Auto-loading config path: com.github.seancorfield/expectations
[clj-kondo] Auto-loading config path: http-kit/http-kit
[clj-kondo] Auto-loading config path: taoensso/encore
[clj-kondo] Auto-loading config path: babashka/fs
WARNING: file hooks/pred_thread_last.clj not found while loading hook
WARNING: error while trying to read hook for ardoq.utils/pred->>: Could not find namespace: hooks.pred-thread-last.
WARNING: file hooks/com/github/seancorfield/next_jdbc.clj not found while loading hook
WARNING: error while trying to read hook for next.jdbc/with-transaction: Could not find namespace: hooks.com.github.seancorfield.next-jdbc.
()
erik@keep ardoq-api %

💥 1
😔 1
emil0r07:04:55

Hela kodbasen för reverie 😮. Lite imponerande att jag hade fler let än defn

([[clojure.core let] 315]
 [[clojure.core defn] 280]
 [[clojure.core if] 245]
 [[clojure.core fn] 179]
 [[clojure.core get-in] 169]
 [[clojure.core assoc] 161]
 [[clojure.core map] 144]
 [[clojure.core str] 120]
 [[clojure.core nil?] 101]
 [[clojure.core defn-] 97]
 [[clojure.core =] 95]
 [[clojure.core ->>] 91]
 [[clojure.core or] 90]
 [[clojure.core get] 89]
 [[clojure.core ->] 87]
 [[clojure.core not] 70]
 [[clojure.core defmethod] 69]
 [[clojure.core do] 65]
 [[clojure.core contains?] 59]
 [[clojure.core keyword] 55]
 [[clojure.core first] 54]
 [[clojure.core and] 52]
 [[clojure.core fn*] 51]
 [[clojure.core swap!] 49]
 [[clojure.core merge] 45]
 [[clojure.core empty?] 45]
 [[clojure.core into] 44]
 [[clojure.core dissoc] 41]
 [[clojure.core def] 40]
 [[clojure.core .] 36]
 [[clojure.core when] 34]
 [[clojure.core assert] 34]
 [[clojure.core assoc-in] 32]
 [[clojure.core if-let] 31]
 [[clojure.core defprotocol] 31]
 [[clojure.core cond] 31]
 [[clojure.core if-not] 31]
 [[clojure.core reduce] 30]
 [[clojure.core defrecord] 30]
 [[clojure.core some] 27]
 [[clojure.core name] 26]
 [[clojure.core doseq] 25]
 [[clojure.core apply] 25]
 [[clojure.core throw] 25]
 [[clojure.core map?] 23]
 [[clojure.core remove] 23]
 [[clojure.core atom] 21]
 [[clojure.core when-not] 20]
 [[clojure.core flatten] 20]
 [[clojure.core try] 20]
 [[clojure.core reset!] 18]
 [[clojure.core filter] 17]
 [[clojure.core extend-type] 17]
 [[clojure.core string?] 16]
 [[clojure.core format] 16]
 [[clojure.core true?] 16]
 [[clojure.core keys] 15]
 [[clojure.core defmulti] 15]
 [[clojure.core vec] 14]
 [[clojure.core list] 12]
 [[clojure.core recur] 12]
 [[clojure.core symbol?] 11]
 [[clojure.core zero?] 11]
 [[clojure.core last] 11]
 [[clojure.core conj] 11]
 [[clojure.core defmacro] 11]
 [[clojure.core select-keys] 11]
 [[clojure.core when-let] 10]
 [[clojure.core partial] 10]
 [[clojure.core keyword?] 9]
 [[clojure.core mapv] 9]
 [[clojure.core defonce] 9]
 [[clojure.core array-map] 9]
 [[clojure.core loop] 9]
 [[clojure.core fn?] 8]
 [[clojure.core key] 8]
 [[clojure.core not=] 8]
 [[clojure.core second] 8]
 [[clojure.core case] 7]
 [[clojure.core pos?] 7]
 [[clojure.core alter-var-root] 7]
 [[clojure.core vals] 7]
 [[clojure.core catch] 7]
 [[clojure.core inc] 7]
 [[clojure.core /] 6]
 [[clojure.core ex-info] 6]
 [[clojure.core type] 6]
 [[clojure.core binding] 6]
 [[clojure.core identity] 5]
 [[clojure.core vector?] 5]
 [[clojure.core extend-protocol] 5]
 [[clojure.core pr-str] 5]
 [[clojure.core slurp] 5]
 [[clojure.core sort-by] 5]
 [[clojure.core sort] 4]
 [[clojure.core count] 4]
 [[clojure.core re-pattern] 4]
 [[clojure.core concat] 4]
 [[clojure.core update-in] 4]
 [[clojure.core re-find] 4]
 [[clojure.core sequential?] 4]
 [[clojure.core subs] 4]
 [[clojure.core butlast] 4]
 [[clojure.core every?] 4]
 [[clojure.core juxt] 3]
 [[clojure.core <] 3]
 [[clojure.core comment] 3]
 [[clojure.core some?] 3]
 [[clojure.core map-indexed] 3]
 [[clojure.core float] 3]
 [[clojure.core set] 3]
 [[clojure.core dec] 3]
 [[clojure.core neg?] 3]
 [[clojure.core condp] 3]
 [[clojure.core false?] 3]
 [[clojure.core ex-data] 3]
 [[clojure.core boolean?] 3]
 [[clojure.core take] 3]
 [[clojure.core reverse] 2]
 [[clojure.core resolve] 2]
 [[clojure.core compare] 2]
 [[clojure.core namespace] 2]
 [[clojure.core println] 2]
 [[clojure.core mod] 2]
 [[clojure.core reduced] 2]
 [[clojure.core ex-message] 2]
 [[clojure.core int] 2]
 [[clojure.core require] 2]
 [[clojure.core >] 2]
 [[clojure.core partition] 2]
 [[clojure.core *] 2]
 [[clojure.core with-out-str] 2]
 [[clojure.core delay] 2]
 [[clojure.core -] 1]
 [[clojure.core *ns*] 1]
 [[clojure.core val] 1]
 [[clojure.core number?] 1]
 [[clojure.core with-open] 1]
 [[clojure.core while] 1]
 [[clojure.core class] 1]
 [[clojure.core int?] 1]
 [[clojure.core print-method] 1]
 [[clojure.core rand-int] 1]
 [[clojure.core any?] 1]
 [[clojure.core meta] 1]
 [[clojure.core group-by] 1]
 [[clojure.core read-line] 1]
 [[clojure.core doall] 1]
 [[clojure.core interpose] 1]
 [[clojure.core record?] 1]
 [[clojure.core set?] 1]
 [[clojure.core drop] 1]
 [[clojure.core merge-with] 1]
 [[clojure.core instance?] 1]
 [[clojure.core proxy] 1]
 [[clojure.core as->] 1]
 [[clojure.core comp] 1]
 [[clojure.core +] 1]
 [[clojure.core qualified-keyword?] 1]
 [[clojure.core re-seq] 1]
 [[clojure.core uuid?] 1]
 [[clojure.core *print-length*] 1]
 [[clojure.core ffirst] 1]
 [[clojure.core symbol] 1]
 [[clojure.core with-meta] 1])

teodorlu07:04:34

@U04V5VAUN kan se ut som du har funnet en bug? Tror kanskje borkdude er interessert i rapport (#CHY97NXE2)

teodorlu07:04:57

>

[[clojure.core unchecked-inc-int] 23]
jeg håpet at dette var i prosjekt der du må bry deg om ytelse. Og det var i replicant! 😁

teodorlu07:04:16

synes disse svarene er kjempegøy å lese. Det er så mye variasjon! keep them coming

schmandle08:04:30

Tror kanskje den er litt dårlig på å telle

❯ ag  "\(defn " src/ | wc -l
1733
❯ clj-kondo --lint src --config '{:analysis true :output {:format :edn}}' | bb -e '(def ana (edn/read-string (slurp *in*))) (prn (->> ana :analysis :var-usages (filter #('"'"'#{clojure.core} (:to %))) (map (juxt :to :name)) frequencies (sort-by second) reverse))' | jet | grep defn
 [[clojure.core defn] 9]

1
schmandle08:04:11

Dette var i et stort cljs prosjekt. I andre prosjekter ser den ut til å telle riktig

teodorlu08:04:19

hmm, mulig du også har funnet en clj-kondo-bug.

schmandle08:04:45

ah, nei, hvis jeg bytter ut clojure.core med cljs.core i filteret, får jeg fornuftige tall

🎉 1
schmandle08:04:12

her er hele resultatet siden @U3X7174KS synes det er gøy

❯ clj-kondo --lint src --config '{:analysis true :output {:format :edn}}' | bb -e '(def ana (edn/read-string (slurp *in*))) (prn (->> ana :analysis :var-usages (filter #('"'"'#{cljs.core} (:to %))) (map (juxt :to :name)) frequencies (sort-by second) reverse))' | jet
([[cljs.core defn] 1733]
 [[cljs.core ->] 1605]
 [[cljs.core if] 1243]
 [[cljs.core let] 909]
 [[cljs.core fn*] 799]
 [[cljs.core fn] 742]
 [[cljs.core str] 631]
 [[cljs.core assoc] 602]
 [[cljs.core .] 592]
 [[cljs.core =] 578]
 [[cljs.core first] 540]
 [[cljs.core or] 535]
 [[cljs.core when] 509]
 [[cljs.core ->>] 406]
 [[cljs.core map] 391]
 [[cljs.core defmethod] 382]
 [[cljs.core not] 367]
 [[cljs.core and] 353]
 [[cljs.core conj] 307]
 [[cljs.core last] 272]
 [[cljs.core into] 253]
 [[cljs.core count] 252]
 [[cljs.core mapv] 231]
 [[cljs.core cond->] 211]
 [[cljs.core filter] 178]
 [[cljs.core get] 165]
 [[cljs.core seq] 164]
 [[cljs.core contains?] 158]
 [[cljs.core update] 147]
 [[cljs.core update-in] 143]
 [[cljs.core partial] 139]
 [[cljs.core dissoc] 133]
 [[cljs.core assoc-in] 128]
 [[cljs.core def] 128]
 [[cljs.core vec] 119]
 [[cljs.core not=] 116]
 [[cljs.core cond] 110]
 [[cljs.core reduce] 108]
 [[cljs.core second] 103]
 [[cljs.core empty?] 95]
 [[cljs.core apply] 94]
 [[cljs.core keyword] 93]
 [[cljs.core set] 91]
 [[cljs.core case] 90]
 [[cljs.core defn-] 89]
 [[cljs.core nil?] 80]
 [[cljs.core identity] 79]
 [[cljs.core merge] 79]
 [[cljs.core <] 79]
 [[cljs.core remove] 78]
 [[cljs.core do] 77]
 [[cljs.core reset!] 75]
 [[cljs.core inc] 74]
 [[cljs.core name] 72]
 [[cljs.core rest] 66]
 [[cljs.core *] 64]
 [[cljs.core if-let] 63]
 [[cljs.core -] 62]
 [[cljs.core some] 61]
 [[cljs.core +] 56]
 [[cljs.core concat] 56]
 [[cljs.core recur] 56]
 [[cljs.core when-not] 54]
 [[cljs.core not-empty] 51]
 [[cljs.core /] 51]
 [[cljs.core >] 50]
 [[cljs.core when-let] 49]
 [[cljs.core keys] 45]
 [[cljs.core clj->js] 45]
 [[cljs.core flatten] 45]
 [[cljs.core vals] 44]
 [[cljs.core comp] 43]
 [[cljs.core loop] 42]
 [[cljs.core vector?] 42]
 [[cljs.core sort-by] 41]
 [[cljs.core butlast] 40]
 [[cljs.core pos?] 40]
 [[cljs.core number?] 38]
 [[cljs.core <=] 38]
 [[cljs.core some?] 37]
 [[cljs.core dec] 37]
 [[cljs.core reverse] 35]
 [[cljs.core peek] 35]
 [[cljs.core string?] 35]
 [[cljs.core defonce] 34]
 [[cljs.core pop] 33]
 [[cljs.core max] 31]
 [[cljs.core map?] 29]
 [[cljs.core map-indexed] 29]
 [[cljs.core subs] 28]
 [[cljs.core select-keys] 27]
 [[cljs.core ..] 27]
 [[cljs.core try] 26]
 [[cljs.core min] 25]
 [[cljs.core get-in] 25]
 [[cljs.core group-by] 25]
 [[cljs.core re-find] 24]
 [[cljs.core filterv] 23]
 [[cljs.core meta] 22]
 [[cljs.core with-meta] 21]
 [[cljs.core if-not] 21]
 [[cljs.core sort] 21]
 [[cljs.core keyword?] 20]
 [[cljs.core interpose] 19]
 [[cljs.core disj] 19]
 [[cljs.core take] 18]
 [[cljs.core re-matches] 18]
 [[cljs.core vector] 17]
 [[cljs.core mapcat] 15]
 [[cljs.core distinct] 15]
 [[cljs.core cons] 15]
 [[cljs.core val] 15]
 [[cljs.core >=] 14]
 [[cljs.core random-uuid] 14]
 [[cljs.core int] 13]
 [[cljs.core aget] 13]
 [[cljs.core coll?] 13]
 [[cljs.core int?] 13]
 [[cljs.core as->] 13]
 [[cljs.core defmacro] 12]
 [[cljs.core nth] 12]
 [[cljs.core for] 12]
 [[cljs.core swap!] 11]
 [[cljs.core take-while] 11]
 [[cljs.core some->] 11]
 [[cljs.core reduce-kv] 11]
 [[cljs.core zipmap] 11]
 [[cljs.core ffirst] 11]
 [[cljs.core while] 11]
 [[cljs.core key] 11]
 [[cljs.core memoize] 10]
 [[cljs.core cond->>] 10]
 [[cljs.core subvec] 10]
 [[cljs.core range] 10]
 [[cljs.core defmulti] 10]
 [[cljs.core every?] 10]
 [[cljs.core js->clj] 9]
 [[cljs.core repeat] 9]
 [[cljs.core set!] 9]
 [[cljs.core drop-while] 8]
 [[cljs.core hash] 8]
 [[cljs.core integer?] 8]
 [[cljs.core neg?] 8]
 [[cljs.core re-pattern] 8]
 [[cljs.core compare] 8]
 [[cljs.core complement] 8]
 [[cljs.core tap>] 8]
 [[cljs.core split-with] 7]
 [[cljs.core keep-indexed] 7]
 [[cljs.core list] 7]
 [[cljs.core interleave] 7]
 [[cljs.core letfn] 7]
 [[cljs.core zero?] 7]
 [[cljs.core comment] 7]
 [[cljs.core force] 6]
 [[cljs.core some->>] 6]
 [[cljs.core atom] 6]
 [[cljs.core juxt] 6]
 [[cljs.core condp] 6]
 [[cljs.core goog.DEBUG] 6]
 [[cljs.core partition] 6]
 [[cljs.core false?] 6]
 [[cljs.core doseq] 5]
 [[cljs.core sorted-map] 5]
 [[cljs.core declare] 5]
 [[cljs.core conj!] 4]
 [[cljs.core not-any?] 4]
 [[cljs.core lazy-seq] 4]
 [[cljs.core boolean] 4]
 [[cljs.core identical?] 4]
 [[cljs.core dotimes] 4]
 [[cljs.core take-last] 4]
 [[cljs.core drop] 4]
 [[cljs.core keep] 4]
 [[cljs.core transduce] 3]
 [[cljs.core with-out-str] 3]
 [[cljs.core doall] 3]
 [[cljs.core new] 3]
 [[cljs.core sequential?] 3]
 [[cljs.core fn?] 3]
 [[cljs.core tree-seq] 3]
 [[cljs.core namespace] 3]
 [[cljs.core deref] 3]
 [[cljs.core seq?] 3]
 [[cljs.core instance?] 2]
 [[cljs.core doto] 2]
 [[cljs.core vreset!] 2]
 [[cljs.core empty] 2]
 [[cljs.core transient] 2]
 [[cljs.core pr-str] 2]
 [[cljs.core *out*] 2]
 [[cljs.core float?] 2]
 [[cljs.core -write] 2]
 [[cljs.core persistent!] 2]
 [[cljs.core println] 2]
 [[cljs.core gensym] 2]
 [[cljs.core defrecord] 2]
 [[cljs.core time] 2]
 [[cljs.core set?] 2]
 [[cljs.core char] 2]
 [[cljs.core volatile!] 2]
 [[cljs.core aset] 2]
 [[cljs.core cycle] 2]
 [[cljs.core this-as] 2]
 [[cljs.core delay] 1]
 [[cljs.core -add-method] 1]
 [[cljs.core even?] 1]
 [[cljs.core next] 1]
 [[cljs.core sorted-map-by] 1]
 [[cljs.core into-array] 1]
 [[cljs.core merge-with] 1]
 [[cljs.core nthrest] 1]
 [[cljs.core enable-console-print!] 1]
 [[cljs.core bit-xor] 1]
 [[cljs.core NaN?] 1]
 [[cljs.core rseq] 1]
 [[cljs.core frequencies] 1]
 [[cljs.core re-seq] 1]
 [[cljs.core constantly] 1]
 [[cljs.core split-at] 1]
 [[cljs.core distinct?] 1]
 [[cljs.core partition-all] 1]
 [[cljs.core long] 1]
 [[cljs.core odd?] 1]
 [[cljs.core iterate] 1]
 [[cljs.core list?] 1])

💯 1
🙏 1
yes 1
schmandle08:04:53

interessant at < er mye mer populært enn > . Er det et personlighetstrekk? :)

cjohansen08:04:26

Jeg syns personlig < er mye lettere å lese og bruker faktisk aldri >

👆 1
teodorlu08:04:30

Jeg bruker også alltid < til fordel for >, liker at ting øker mot høyre!

teodorlu08:04:26

[[cljs.core defmethod] 382]Denne er jeg fryktelig nysgjerrig på! Bruker du polymorfisme/generics aktivt i arkitekturen deres? (som feks https://mitpress.mit.edu/9780262045490/software-design-for-flexibility/ argumenterer for)

schmandle08:04:27

ja, et par plasser. Ikke sikkert det hadde blitt gjort sånn om vi skulle startet på nytt. De er litt vonde å jobbe med i repl imho

👍 1
schmandle08:04:35

dette er et statistikkverktøy med et eget språk. multimetodene er mye brukt for å dispatche til passende render funksjon for resultatene av de ulike kommandoene vi har

👍 1
teodorlu05:04:43

Dette var skikkelig spennende. Takk til alle som delte! Én ting som slo meg var at det var lite defrecord og defprotocol, og mye bruk av operasjoner som jobber på data.

cjohansen05:04:02

defrecord bruker jeg så og si aldri. defprotocol har sin plass i biblioteker, men selv der blir det sjelden veldig mange. Men noen få kan gi deg utrolig stor fleksibilitet.

👍 1
oddsor08:04:49

Advent of code:

([[clojure.core defn] 281]
 [[clojure.core =] 218]
 [[clojure.core map] 184]
 [[clojure.core ->>] 144]
 [[clojure.core let] 138]
 [[clojure.core fn] 130]
 [[clojure.core +] 122]
 [[clojure.core inc] 110]
 [[clojure.core apply] 107]
 [[clojure.core count] 102]
 [[clojure.core slurp] 93]
 [[clojure.core first] 83]
 [[clojure.core assert] 80]
 [[clojure.core def] 74]
 [[clojure.core fn*] 69]
 [[clojure.core comment] 67]
 [[clojure.core dec] 64]
 [[clojure.core if] 63]
 [[clojure.core range] 54]
 [[clojure.core filter] 50]
 [[clojure.core partial] 49]
 [[clojure.core *] 48]
 [[clojure.core -] 41]
 [[clojure.core reduce] 40]
 [[clojure.core comp] 40]
 [[clojure.core >] 36]
 [[clojure.core read-string] 35]
 [[clojure.core parse-long] 32]
 [[clojure.core re-seq] 30]
 [[clojure.core ->] 29]
 [[clojure.core set] 27]
 [[clojure.core max] 26]
 [[clojure.core vals] 26]
 [[clojure.core and] 26]
 [[clojure.core second] 26]
 [[clojure.core mapcat] 25]
 [[clojure.core into] 25]
 [[clojure.core zero?] 24]
 [[clojure.core /] 24]
 [[clojure.core min] 24]
 [[clojure.core partition] 24]
 [[clojure.core take] 24]
 [[clojure.core for] 23]
 [[clojure.core update] 22]
 [[clojure.core identity] 22]
 [[clojure.core last] 22]
 [[clojure.core recur] 22]
 [[clojure.core remove] 21]
 [[clojure.core when] 20]
 [[clojure.core iterate] 20]
 [[clojure.core nth] 20]
 [[clojure.core >=] 20]
 [[clojure.core str] 18]
 [[clojure.core drop] 17]
 [[clojure.core loop] 17]
 [[clojure.core val] 16]
 [[clojure.core if-let] 16]
 [[clojure.core nil?] 16]
 [[clojure.core <] 15]
 [[clojure.core mapv] 15]
 [[clojure.core number?] 14]
 [[clojure.core assoc] 14]
 [[clojure.core juxt] 14]
 [[clojure.core cond] 14]
 [[clojure.core sort] 13]
 [[clojure.core list] 13]
 [[clojure.core get] 13]
 [[clojure.core or] 13]
 [[clojure.core keys] 13]
 [[clojure.core conj] 12]
 [[clojure.core get-in] 11]
 [[clojure.core concat] 11]
 [[clojure.core time] 11]
 [[clojure.core map-indexed] 11]
 [[clojure.core some] 11]
 [[clojure.core keep] 10]
 [[clojure.core int] 10]
 [[clojure.core merge] 9]
 [[clojure.core .] 9]
 [[clojure.core mod] 9]
 [[clojure.core true?] 9]
 [[clojure.core cons] 9]
 [[clojure.core seq] 8]
 [[clojure.core frequencies] 8]
 [[clojure.core vector] 8]
 [[clojure.core reverse] 7]
 [[clojure.core compare] 7]
 [[clojure.core rest] 7]
 [[clojure.core not] 7]
 [[clojure.core every?] 7]
 [[clojure.core case] 6]
 [[clojure.core take-last] 6]
 [[clojure.core repeat] 6]
 [[clojure.core when-let] 6]
 [[clojure.core vec] 6]
 [[clojure.core lazy-seq] 6]
 [[clojure.core keyword] 6]
 [[clojure.core symbol] 6]
 [[clojure.core take-while] 5]
 [[clojure.core reduced] 5]
 [[clojure.core sort-by] 5]
 [[clojure.core update-in] 5]
 [[clojure.core <=] 5]
 [[clojure.core conj!] 5]
 [[clojure.core condp] 5]
 [[clojure.core cycle] 5]
 [[clojure.core transduce] 4]
 [[clojure.core distinct] 4]
 [[clojure.core ex-info] 4]
 [[clojure.core defn-] 4]
 [[clojure.core when-not] 4]
 [[clojure.core dissoc] 4]
 [[clojure.core group-by] 4]
 [[clojure.core prn] 4]
 [[clojure.core partition-by] 4]
 [[clojure.core coll?] 4]
 [[clojure.core throw] 4]
 [[clojure.core with-bindings] 4]
 [[clojure.core reductions] 4]
 [[clojure.core not-any?] 4]
 [[clojure.core not=] 4]
 [[clojure.core char] 4]
 [[clojure.core map?] 3]
 [[clojure.core cond->] 3]
 [[clojure.core re-matches] 3]
 [[clojure.core println] 3]
 [[clojure.core vector?] 3]
 [[clojure.core some?] 3]
 [[clojure.core drop-while] 3]
 [[clojure.core take-nth] 3]
 [[clojure.core merge-with] 3]
 [[clojure.core vswap!] 3]
 [[clojure.core vector-of] 3]
 [[clojure.core tree-seq] 3]
 [[clojure.core volatile!] 3]
 [[clojure.core select-keys] 3]
 [[clojure.core dotimes] 2]
 [[clojure.core bit-test] 2]
 [[clojure.core string?] 2]
 [[clojure.core resolve] 2]
 [[clojure.core replace] 2]
 [[clojure.core odd?] 2]
 [[clojure.core hash-map] 2]
 [[clojure.core zipmap] 2]
 [[clojure.core doto] 2]
 [[clojure.core keep-indexed] 2]
 [[clojure.core persistent!] 2]
 [[clojure.core split-at] 2]
 [[clojure.core filterv] 2]
 [[clojure.core float] 2]
 [[clojure.core some->] 2]
 [[clojure.core re-find] 2]
 [[clojure.core neg?] 2]
 [[clojure.core *in*] 2]
 [[clojure.core abs] 2]
 [[clojure.core ffirst] 2]
 [[clojure.core assoc-in] 2]
 [[clojure.core transient] 2]
 [[clojure.core distinct?] 2]
 [[clojure.core long] 2]
 [[clojure.core butlast] 2]
 [[clojure.core symbol?] 1]
 [[clojure.core list?] 1]
 [[clojure.core complement] 1]
 [[clojure.core empty?] 1]
 [[clojure.core map-entry?] 1]
 [[clojure.core deref] 1]
 [[clojure.core contains?] 1]
 [[clojure.core pos?] 1]
 [[clojure.core sequence] 1]
 [[clojure.core ..] 1]
 [[clojure.core reduce-kv] 1]
 [[clojure.core *warn-on-reflection*] 1]
 [[clojure.core pop] 1]
 [[clojure.core do] 1]
 [[clojure.core interpose] 1]
 [[clojure.core name] 1]
 [[clojure.core eduction] 1]
 [[clojure.core not-every?] 1]
 [[clojure.core declare] 1]
 [[clojure.core every-pred] 1]
 [[clojure.core set!] 1]
 [[clojure.core pmap] 1]
 [[clojure.core empty] 1]
 [[clojure.core constantly] 1]
 [[clojure.core cond->>] 1]
 [[clojure.core assoc!] 1]
 [[clojure.core fnil] 1]
 [[clojure.core lazy-cat] 1]
 [[clojure.core cat] 1]
 [[clojure.core neg-int?] 1]
 [[clojure.core key] 1]
 [[clojure.core false?] 1]
 [[clojure.core subs] 1]
 [[clojure.core eval] 1]
 [[clojure.core ex-data] 1]
 [[clojure.core flatten] 1]
 [[clojure.core next] 1]
 [[clojure.core try] 1]
 [[clojure.core quot] 1])

teodorlu08:04:21

@UDB2Q0W13 spennende! Vil du si noe om hvordan du bruker assert?

oddsor08:04:20

Nei, egentlig ikke! 🙈 Det er et slags anti-pattern jeg la til meg når jeg løste oppgaver. I advent of code har man ofte et lite test-case med et svar, så jeg la til en assert for det caset. Men man vil jo gjerne heller bruke ordentlige tester (og det har jeg også begynt med underveis i prosjektet)

😄 1
teodorlu08:04:19

Jeg mener ikke at det er noe å skamme seg over, altså! Er ikke “ha nok asserts” litt av greia med design by contract? https://en.wikipedia.org/wiki/Design_by_contract

oddsor08:04:02

Hehe, kanskje det! Men jeg bruker det definitivt ikke på den måten 😅

teodorlu08:04:41

tja, jeg ville tenkt at en assert fort kan passe enten i “precondition”-bøtta eller “postcondition”-bøtta! 😸

emil0r07:04:09

God morgon 🙂

leifericf08:04:37

Møøørn!

🐮 1
leifericf09:04:25

Av annet nytt klarte jeg omsider å inspirere vår Tech Director til å prøve https://www.youtube.com/watch?v=c5QF2HjHLSE&t=2350s 🙂 Ser han sitter og fyller ut i Excel nå.

rich2 6
🤌 2
teodorlu10:04:56

Jeg trykket akkurat C-c C-c for å prøve å sende en melding i Slack 😅

😂 3
Zeniten10:04:35

Hvordan setter dere opp nye prosjekter? (Jeg følger denne https://blog.michielborkent.nl/new-clojure-project-quickstart.html nå og tester neil.)

Zeniten10:04:55

Er det mest manuell bygging fra scratch?

magnars10:04:36

Ja, med litt varsom kopiering fra andre prosjekter. Anbefaler forresten https://github.com/lambdaisland/launchpad

👍 1
Zeniten10:04:08

Launchpad skal med. 😄

cjohansen11:04:35

Jeg starter ikke prosjekter ofte nok til at det er verdt å standardisere for mye. Nesten hver gang jeg starter et nytt prosjekt er det noe som er litt annerledes. Nå sist var det launchpad, feks.

magnars11:04:21

ja, det blir mest å optimalisere for å gjenta gamle feil 😅

magnars11:04:47

for meg blir det litt som at jeg setter opp Mac'en min på nytt når jeg skal installere en ny

magnars11:04:00

da er det på tide å ta en liten revurdering av hva jeg faktisk vil ha med meg videre

💯 1
🧹 1
Zeniten11:04:08

Vet dere om Launchpad satt opp ved å følge repoets readme bare fungerer på Linux-systemer?

Zeniten11:04:41

Dette er vel ikke noe Windows vil kjenne til? > #!/usr/bin/env bb

teodorlu11:04:13

neil-quickadd for deps, bbadd for launchpad og kaocha https://github.com/teodorlu/neil-quickadd https://github.com/teodorlu/shed/blob/master/src/teodorlu/shed/bbadd.clj Bbadd har ikke fått sitt eget repo, men det står hvordan man kan installere i clojure-scriptet. Begge to sheller ut til neil, så neil må være installert.

👀 1
teodorlu11:04:34

@U9CU2PQPM nei, den må man vel ha WSL for at skulle kunne fungere. Merk: du trenger faktisk ikke bin/launchpad og bin/kaocha, du kunne like gjerne kjørt kommandoene de scriptene kjører selv. For bin/kaocha tror jeg å lage bin/kaocha.bat bør fungere bra.

👍 1
cjohansen11:04:52

Windows 😱

🔥 1
🪟 1
1
😄 1
Zeniten11:04:53

Jeg tenker å gjøre babashka til repoets cli. Da kan jeg lage en task slik at bin/launchpad kjøres via den.

Zeniten11:04:16

Et tu, Windows?!

teodorlu11:04:00

> Jeg tenker å gjøre babashka til repoets cli. Da kan jeg lage en task slik at bin/launchpad kjøres via den. > Det tror jeg vil funke veldig bra! Man kan argumentere for at bb launchpad er vel så greit å skrive som bin/launchpad, og det kan være fint å ha sånne stubs i en fil (bb.edn) i stedet for mange stubs (bin/...).

Zeniten11:04:23

Jepp, men jeg tror at jeg skal følge konvensjonen som lambdaisland forfekter, i håp om å forvirre minst mulig.

teodorlu12:04:30

til info (du velger selvfølgelig selv hva du gjør), borkdude valgte å ikke legge inn binstub i neil add kaocha-kommandoen fordi han mente at folk måtte kunne velge binstubs selv: https://clojurians.slack.com/archives/C03KCV7TM6F/p1713026328407439 (men jeg gjør akkurat det samme som deg, jeg legger til bin/kaocha og bin/launchpad og synes det funker bra)

👌 1
Zeniten12:04:35

Ser dette ok ut, @U3X7174KS? > {:deps {com.lambdaisland/launchpad {:mvn/version "0.28.129-alpha"}} > :tasks > {start {:doc "Run application" > :task (shell "bb bin/launchpad")}

teodorlu12:04:44

Tror også

{:deps {com.lambdaisland/launchpad {:mvn/version "0.28.129-alpha"}}
 :tasks
 {start (shell "bb bin/launchpad")}}
bør fungere.

teodorlu12:04:21

Men du vet at bin/launchpad bare er bb-kode som du kan putte rett i bb.edn?

teodorlu12:04:40

er er en eksempel på en bin/launchpad:

(require '[lambdaisland.launchpad :as launchpad])

(launchpad/main {})
Jeg tror det finnes et sted i bb.edn du kan putte require (`(require '[lambdaisland.launchpad :as launchpad])` og så kan start bare være (launchpad/main).

Zeniten12:04:36

Ja-o, det er kanskje bedre. Jeg tenkte at jeg skulle "gjenbruke" bin/launchpad, men det trenger jeg jo ikke.

teodorlu12:04:10

du kan jo gjøre det hvis du vil, men da kjører du en bb inni en annen bb når du bare trenger én bb. Jeg ville tenkt at det var lettere å forstå koden uten en ekstra bb-prosess som venter på en annen bb-prosess.

Zeniten12:04:48

Aha, jeg er solgt.

Zeniten12:04:33

Da oppstod et problem: Hvordan sørge for at bin/launchpad og bb start bruker samme konfigurasjon? Men det kan jeg vel eventuelt legge i en .edn-fil og hente inn begge steder. 😊

Zeniten12:04:46

(For jeg ønsker å tilby begge delene. 😺)

teodorlu12:04:44

> Hvordan sørge for at bin/launchpad og bb start bruker samme konfigurasjon? Jeg ville intuitivt tenkt at da kan du slette den ene 😄 Alternativt kan du putte config i en fil (feks config.edn) og lese den med (clojure.edn/read-string (slurp "config.edn")).

teodorlu12:04:27

Jeg har ikke trengt config til launchpad ennå, så jeg har ikke hatt det problemet ennå. Jeg kjører

bin/launchpad -emacs
, så er jeg fornøyd.

Zeniten12:04:12

Ja, det virker fint. Jeg har bare lyst til at folk som er vant med å kjøre bin/launchpad, fortsatt skal ha den muligheten.

teodorlu12:04:54

Hvis det er målet ville jeg shellet ut til bb start fra bin/launchpad. (det var vel kanskje det du foreslo over).

Zeniten12:04:24

Nei, men kanskje jeg skal gjøre det.

Zeniten12:04:18

Nå kan man kjøre begge disse for å starte launchpad: • bb dev (byttet fra start) • bin/launchpad

Zeniten12:04:34

Hvordan ville dere ha kjørt -main-funksjonen? Det er kanskje her et eget dev-navnerom kommer naturlig inn? For å komme i gang så gjør man f.eks. da: 1. Kjør bb dev og koble til editoren. 2. Evaluer dev-navnerommet.

Zeniten12:04:40

Hva synes dere?

magnars12:04:12

Det er vanlig å starte systemet fra et dev-navnerom

magnars12:04:46

og ha en main-metode for å starte fra terminalen - i prod

teodorlu12:04:51

I en https://github.com/teodorlu/weeknotes-notes/tree/af73593a6c744a26083f4e744daa122eee70577c/./ har jeg bin/launchpad akkurat sånn den anbefales fra README i appen, og user.clj som ser sånn ut:

(ns user
  (:require
   integrant.repl
   [weeknotes-notes.core :as core]
   [clj-reload.core :as clj-reload]))

#_{:clj-kondo/ignore [:clojure-lsp/unused-public-var]}
(defn restart! []
  (require 'weeknotes-notes.system)
  (integrant.repl/set-prep! weeknotes-notes.core/default-config)
  (integrant.repl/halt)
  (clj-reload/reload)
  (integrant.repl/go))

;; run restart! from a REPL to start!
Jeg bruker dynamisk require inni restart! for å sørge for at jeg kan starte en REPL selv om jeg har syntaksfeil i koden. (tror det stemmer ganske bra med hva Magnar anbefaler over)

Ivar Refsdal19:04:51

https://github.com/tonsky/clj-reload ser awesome (eventuelt: råkult) ut. launchpad ser også bra ut. kaocha: gode greier for tester, gjorde meg merksam på logiske feil i eigne testar. https://github.com/teodorlu/neil-quickadd av @U3X7174KS er heilt konge/dronning også, eg nyttar det stadig vekk 👍 Eit prosjekt eg ikkje har sett nemnt her på kanalen er https://github.com/liquidz/build.edn som gjer mykje av det same som ulike lein kommandoer (CC @U04V5VAUN), fungerer heilt greit synest eg:

$ clojure -T:build help
add-snapshot       - Add '-SNAPSHOT' to version number and update configuration file
bump-major-version - Bump major version and update configuration file
bump-minor-version - Bump minor version and update configuration file
bump-patch-version - Bump patch version and update configuration file
deploy             - Deploy this library to a remote Maven repository
execute            - Execute one or more functions at once
help               - Print this help
install            - Install this library to your local Maven repository(~/.m2)
jar                - Generate JAR file
java-compile       - Compile Java sources
lint               - Lint your build.edn file
pom                - Generate pom.xml
remove-snapshot    - Remove '-SNAPSHOT' from version number and update configuration file
uberjar            - Generate standalone JAR file
update-documents   - Update document files for a new release

😊 1
2
pez12:04:20

Morn fra Suno.

catjam 5
😂 2