clojure-norway 2025-11-14

tenkte det var en spesielt god morgen, sola skinner og det er blå himmel 😂

😂 5

I så fall syns jeg du kunne kosta på deg et utropstegn @odinodin

😂 1

Jeg mistenker at Terje har flyttet sin SoMe-strategi til en agentisk AI. 😂

😂 4

Forrige melding fra meg var vel en YubiKey-kode som kom feil.. har vi en kanal hvor jeg kan øve litt på Slack?;)

😂 4

Her sier alle god morgen. Men kun én får refs. Sånn er det noen ganger.

😂 1

Hva gjelder det?

1
😂 3

Jeg har prøvd å nå deg ang. forsikringen din. Hva betaler du i dag?

😂 4

Er det dette som er Pig butchering?

🔪 1
🐷 1

Ja, egentlig er jeg forsikringsmegler. De siste 5~6 årene med Clojure-læring har kun vært for å vinne deres troverdighet og tillit. Nå føltes tiden riktig. #VerdensMestLidenskapeligeForsikringsselger

😂 5

Jeg mistenker at dette kan gjøres på en mer elegant måte, men jeg vet ikke hvordan. Denne funksjonen sjekker om et map-verdi inneholder visse termer:

(defn field-contains?
  [map key terms]
  (some #(str/includes?
          (str/lower-case (key map))
          (str/lower-case %))
        terms))
Eksempel på hvordan jeg bruker den:
(->> employees
     (filter #(field-contains? % :jobTitle ["architect"
                                            "devops"
                                            "engineer"
                                            "programmer"
                                            "programming"
                                            "scripter"
                                            "systems"
                                            "tech"
                                            "technical"]))
     (map :workEmail)
     (map str/lower-case)
     (distinct)
     (sort)
     (dump-to-file "emails.txt" "output"))
Det er denne biten jeg synes ser ganske stygg/uleselig ut:
(filter #(field-contains? % :jobTitle ["architect"
                                            "devops"
                                            "engineer"
                                            "programmer"
                                            "programming"
                                            "scripter"
                                            "systems"
                                            "tech"
                                            "technical"]))
Hvordan hadde dere gjort dette?

Min dump-to-file ser slik ut:

(defn dump-to-file
  "Dump data as plain text to file in specified directory."
  [file-name dir-name data]
  (let [path (fs/path (fs/cwd) dir-name)]
    (when-not (fs/exists? path)
      (fs/create-dirs path))
    (spit (str (fs/path path file-name))
          (str/join "\n" data))))
Jeg bruker den slik:
(->> employees
       (map :jobTitle)
       (distinct)
       (sort)
       (dump-to-file "job-titles.txt" "output"))

Jeg ville helt sikkert påstått at det å regne ut hvor noe skal skrives er ortogonalt fra det å skrive det ut.

Jeg hadde ekstrahert en mer fokusert funksjon:

(defn has-job-title?
  [job-titles]
  #(field-contains? % :jobTitle job-titles))

(->> employees
     (filter (has-job-title? ["architect"
                              "devops"
                              "engineer"
                              "programmer"
                              "programming"
                              "scripter"
                              "systems"
                              "tech"
                              "technical"]))
     #_osv.)
Og kanskje også lista med titler:
(def tech-jobs ["architect" "devops" "engineer" "programmer" "programming"
                "scripter" "systems" "tech" "technical"])

(->> employees
     (filter (has-job-title? tech-jobs))
     #_osv.)
(`tech-jobs` kan også være i en let rundt uttrykket ditt, litt avhengig av hvordan koden er organisert.)

👍 1
👀 1

Det gir mening! Takk for tips. Det var faktisk mer slik i starten, så gikk jeg antagelig for langt i den «generelle/abstrakte» retningen 😅

Merker jeg ofte tenker at jeg har for mange små domenespesifikke funksjoner istedenfor å bruke innebygde funksjoner «utenfor» når jeg kombinerer dem.

Jeg må bli flinkere til å finne riktig abstraksjonsnivå å legge meg på.

Altså, det er ingenting i veien med det du viste først heller. Man må nesten velge selv ut fra situasjonen hvor man vil legge seg på abstraksjons-spekteret. 🙂 Jeg pleier å begynne ikke-abstrakt men domene-nært. Tiden viser om det er lurt å abstrahere.

👍 1

Det første jeg hadde tenkt her, var å putte alle stillingstitlene i et set fordi set er funksjoner. Så:

(def titles #{"devops" "engineer" "programmer"})
;;
(titles "devops") ;;=> "devops"
(titles "wizard") ;;=> "null"
Da kan du golfe litt:
(filter (comp titles str/lower-case :jobTitle) employees)

💡 1
😮 1

(dump-to-file) høres ut som spit