morning

Morning beautiful people

morning all

@conan back in '14 we tried using Datomic for geosearches. Elasticsearch was a much better fit here.

I like Datomic too btw

😼 moin moin

got to stop... procrastinating.... on talk preparation... time for coffee and dedication

månmån

Morning

Any recommendations on passing a Clojure cmd-line tool a string? I would expect this to work: java -jar target/uberjar/bar-0.1.0-SNAPSHOT-standalone.jar "foo", but nothing is returned?

or actually just an argument, doesn’t need to be a string…

I’ve looked at a number of examples, but none quiet hit what I’m looking for

@jonpither yeah, datomic + elasticsearch is lovely

@seb231 that should come through as an arg to the -main function, right?

@conan yes

@seb231 how does your -main look?

yeah @dominicm I was just thinking a better/actual example might be in order!

(defn -main
  "I don't do a whole lot ... yet."
  [& args]
  (prn args))

/tmp/foo
❯ java -jar target/uberjar/foo-0.1.0-SNAPSHOT-standalone.jar     
nil

/tmp/foo
❯ java -jar target/uberjar/foo-0.1.0-SNAPSHOT-standalone.jar foo
("foo")

Based on the lein app template

clojure.tools.cli/parse-opts might give you a clue https://github.com/clojure/tools.cli

@seb231 ^^

thanks both 🙂

can confirm tools.cli is useful

my main:

(defn -main [database]
  (prn (query-nhm-api database "Archaeopteryx")))

this works from cmd line if I hard code the entry for database, but I would like to get to a point where database and the string (“Archaeopteryx”) are both args

> database is a number of def’ed objects in the same namespace. Perhaps that is my issue? (edited) Clojure can handle shadowing just fine, e.g.:

(let [db 10]
  (let [db 20]
    db))
;; => 20

but @dominicm I don’t think the cmd line knows what I mean when I give it an argument for database. For example java -jar target/uberjar/dippi-0.1.0-SNAPSHOT-standalone.jar collection-specimens collection-specimens is a def’ed object in the namespace, but why would the cmd line know what/where that is?

:thinking_face: What is your issue exactly?

I think I need to actually spend some more time with clojure.tools.cli

this: java -jar target/uberjar/dippi-0.1.0-SNAPSHOT-standalone.jar collection-specimens doesn’t return anything from cmd line, but works fine from the REPL (`(-main collection-specimens)`)

They're different 😉

Okay, I understand now

sorry 😬

You want collection-specimens at the CLI to refer to dippi.core/collection-specimens ?

yeah!

gotcha, one sec

(ns foo.core
  (:gen-class))

(def thing "some-value")

(defn -main
  "I don't do a whole lot ... yet."
  [lookup]
  (prn @(resolve (symbol lookup))))

/tmp/foo
❯ java -jar target/uberjar/foo-0.1.0-SNAPSHOT-standalone.jar foo.core/thing
"some-value"

However, don't think this is generally a good idea, recommend you do something like this:

(def dbs
  {"collect-speciments" collect-specimens})

everyone

Thanks a lot @dominicm got it working with @(resolve (symbol lookup)) just need to make it more secure as you suggest 🙂

Interesting conversation

(the CLI args stuff, I mean)

woah, did not expect this. If you do (prn *ns*) inside of -main, you get clojure.core

If you use:

(defn -main
  "I don't do a whole lot ... yet."
  [lookup]
  (prn @(ns-resolve (find-ns 'foo.core) (symbol lookup))))

Mornin’

mroninggg

Question for the day, as this is bothering me right now: How do people treat their git commits? Seems to be a couple of approaches: * commits like s, stuff, implements X, does X & Y & Z * commits are "Rewrite X\n\nOld X sucked because A, B, C (See GH-10). New X uses floobits to ensure that fellanges are entirely secure at all times." I find myself doing the latter form, and avoiding the "X & Y & Z" via careful use of Magit to make it "X" "Y" "Z"

I'm guessing the real answer is "What will your team agree to do" 😆

i tend to try to follow the advice from https://chris.beams.io/posts/git-commit/

@sundarj skimmed that article just now, it seems to mirror what I attempt to do.

@dominicm great 😛

in a team, something like Commitizen is also a good idea

Re-posting here in case anyone knows: >Are there any online resources / books that would teach about the underlying architecture of Clojure? I'm looking for things that would help me to understand how Clojure actually works (code compilation/execution, behind the scenes processes, caveats with things like macros, etc.) as opposed to things like syntax and results of running code.

I would ask that Q of @reborg

he spends a lot of time with his head under the bonnet

hey @yogidevbear, no resources of that kind in a single place AFAIK

there are several talks on the topic (one is mine) about following the journey of an s-expression into the compiler down to bytecode

That sounds perfect

Someone else did suggest https://www.youtube.com/watch?v=6DaBmz_6y0s&index=9&list=WL

yeah, another is https://vimeo.com/100518965

would be nice to collect all the resources together

A nice experience to try is to put a breakpoint in intellij somewhere in LispReader and fire up the repl in debug mode to follow step by step

Are there any videos/posts on that (intellij/LispReader/repl in debug mode)?

I don't know of any but I can create one 🙂

That would be amazing!

Ok, let me see what I can do in the following days

Morning

@gjnoonan - Morning 🙂 How’s it?

i could do a talk about how the internals of clojure work at some london meetup in the future, if there's interest

I'd come down to see that

looking forward to that @bronsa

afternoon