hi guys, is this the right place to ask about how to train new developer to use Clojure ?

@nxqd Either here or #beginners depending on their background I guess...

@seancorfield I wonder how do you guys train new developer to learn clojure ? I find that most of them find the syntax is weird :)) , and they find other language ( like go ) much more productive ? I would love to find a good way to communicate and sell Clojure to them ? Where should I start ? ( like, writing the same language front end and backend, no more type and static type. clojure.spec ) ...

Depending on what languages they already know, there are likely two things they’ll find “hard” about Clojure: 1) syntax — although this really is a minor issue as Clojure has very little syntax: it’s just slightly different to C-family languages 2) FP — no mutable state, no encapsulation (In the OOP sense), no “variables”, no traditional loops. The latter is usually the biggest stumbling block if they have only ever programmed in Java for example.

My question would be: under what circumstances are you trying to train them? Is it because you want to switch your current company from Language X to Clojure? Is it because you’ve started using Clojure on your team and need to grow that team?

Do your management want you to use Clojure? Or are you trying to persuade them?

Great answer. For now, I have an authority to build my own team ( of 3 for now ) , they are fluent in other imperative languages ( go, python, java ). And I would love to grow this team with Clojure. My approach at the moment is to let them get familiar with the language through clojurekoans, and listen to their feedback. Along with their learning, I will try to feed some good examples of why Clojure is lean and more productive than other language ( through simple example cljs, clojure, building simple API .. ). I find productive seems to be the most interesting thing they love about learning a new language.

@seancorfield do you ask the team to use standard tools, i.e. everyone on IntelliJ, or everyone on Emacs for example?

@nxqd the thing that attracted me to clojure in the first place was the focus on simple programs that are easy to maintain because they’re mostly just pure functions

maintainability is super important IMO - i’ve seen codebases in python where the original programmers were very productive in the beginning, but development years down the line had slowed to a crawl because the codebase relied so much on inheritance + mutable state that it was very difficult to understand anything / confidently make changes to things

@jrheard good point. I will take note this one

i had to print a “MultiDomainMixin” class (and two other classes that used it) out and tape them to a wall and spend two weeks marking them up with a pen before i was able to make a change one time 🙂

@rymndhng We “encourage” our team to all use standardized tooling as that makes pair programming easier but we don’t enforce anything specific. Everyone just happens to be on Emacs on the server side team 🙂

Becoming productive with Clojure takes a while @nxqd because the functional idioms are so different to most “traditional” mainstream languages (certainly the case compared to Go, Python, and Java). Some folks adapt quicker than others.

Clojure encourages you to think more deeply about your initial design / solution but we’ve generally found maintenance remains easier over time — we don’t suffer from the “big ball of mud” problem that @jrheard hints at with OOP / imperative code.

That’s not to say we don’t sometimes decide to do some major refactoring but even that seems easier when you’re dealing with (mostly) pure functions rather than classes with their own mutable state.

Thanks

@nxqd: One of the biggest selling points for me was the ability to use Clojure on the back end and ClojureScript on the front end, and with Garden for CSS I have very little context switching now.

Can anybody explain why this works? (let [{:qux :foo} {:foo 10 :bar 20}] qux) (returns 10, Clojure 1.8.0)

luck?

in 1.9 it's a syntax/spec error from the let macro

@bfabry Ah, thanks!

Hey, would the community weigh in on their boot/lein preference and more importantly - some reasoned arguments as to why they favour what they do

@pseud I still prefer leiningen for the sole reason that boot has issues that make it unusable on W 7 / 8. At least that was the state like 6 months ago: https://github.com/boot-clj/boot/issues?utf8=%E2%9C%93&q=is%3Aissue%20is%3Aopen%20windows Also leiningen has not let me down so far and gives me everything I need and cursive has great support for it, whereas it is harder for cursive to support boot (I remember @cfleming saying that some time ago)

@sveri thanks for your input 🙂

The floor is still open, I’d love more input

@pseud: I develop Cursive, and it is definitely much harder to develop tooling for. That may only affect Cursive, though, since AFAIK it’s the only tool that needs to get much information from the build itself.

@cfleming so would you say that boot support would, eventually, be able to surpass support for Leiningen ?

I doubt it. At best, it’ll be able to match it. Lein has its own problems WRT integration into tools like Cursive, but the support is pretty mature now.

@pseud lein allows you to get started writing your app directly, and provides a nice base structure if you’re not an expert, which is reason enough for me

lein just works, no reason to switch on my end. boot looks interesting but I didn't have a compelling reason to invest time in it so far

How does one redefine a defmethod at the REPL?

seems to not ‘just work'

@borkdude works for me if you just do a defmethod with the same key/selector

@nxqd I can confirm this; I now have 3 fairly sizeable clojure/cljs apps in production. It's great not having to switch context! Once you work with it and you have one buildtool, one REPL, one flow, it just feels soooo much lighter. And then there is maintainability, as @seancorfield mentioned. I actually dare to refactor stuff. I remember back in the java days, and the occasional moments i have to go back to java, that i start programming much more functionally in the OO language that is java, just because it's so much easier to reason about. I remember Rich hickey also mentioning this 'at one point i was writing functional code in C++' i think he said

immutability is really really an important concept

(imo)

@dm3 Ah thanks, it appeared to be something else

speaking of @borkdude: absolutely loved your tweet yesterday: 'REPL REPL, your state is a mess'

😄

hehe. thanks

it was extra funny because at the time I was actually listening to Bowie 😉

now i can't hear that song anymore without thinking about that

Hi. What is the elegant way to check for first part of a key? I have k which is a key like :a/a or :b/a. I need a sexp which yields true if the first part is :a

Should I convert the key to a string and call startsWith?

namespace function

(namespace :foo/bar) ;;=> “foo”

@pseud: check out my blog for a series of articles on why we switched from Leiningen to Boot at World Singles http://seancorfield.github.io

I can't wait to read those this evening

i'm interested in learning about boot

@dpsutton if you have a leiningen project you want to convert to boot: http://blog.michielborkent.nl/blog/2015/06/06/from-leiningen-to-boot/ (shameless plug)

do you have the hacker news link by any chance?

i love reading comments as well

I googled it: https://news.ycombinator.com/item?id=9671106

ah sorry. but thanks!

wasn’t there something against linking directly to hacker news?

new to me

I’ve looked at boot also and haven’t had any compelling reason to try it out. I don’t see what benefits it offers and I haven’t hit a snag in lein that will force me to try out boot in anger.

@roberto : Some thoughts on Boot. I find that Boot helps me attain the ideal of hacking on live code more easily than Leiningen (my projects are almost entirely server-side, so lein figwheel doesn’t apply). I also find it much more flexible for builds across multiple projects. The flexibility means that once you depart from the well-trod path there is code to write. If you need the flexibility, this is great. If you don’t, you might find that Leiningen is easier—until the day you realize you need the flexibility. Hope this helps.

yeah, it seems to me more like a power tool that the majority of us might never need

Until you do. 😉

I'm having trouble with clojure.java.jdbc performance. When using insert-multi!, inserting 1000 rows over a remote connection is very slow, almost as if the driver did a round-trip for each insert value.

that's on postgresql/AWS's RDS. Any ideas? (am I doing it wrong, @seancorfield?)

pesterhazy: it generates one gigantic insert: https://github.com/clojure/java.jdbc/blob/master/src/main/clojure/clojure/java/jdbc.clj#L1088

@albaker yeah that's what I expected (using a prepared statement)

oops, I'm looking at the wrong one

you were right it does do them one at a time, and postgres returns the row back

for each one

You'll want to use the other form of insert with the vectors of column values instead of maps, I think. I'm on my phone right now and can't check.

let me check

ahhh:

When inserting a row as a list of column values, the result is the count of
  rows affected (1), if available (from getUpdateCount after executeBatch).

If you provide maps, the assumption is they might not all be the same shape. If you provide column values, they have to be the same shape.

just tried it, it works

thanks @seancorfield, that was tremendously helpful

that wasn't obvious to me at all from the docstring

it makes sense when you think about it

I've toyed with the idea of adding an option to convert the maps into the vector form (and throw an exception if they don't match). It would have to be an option.

but my expectation was that the two types of inputs are roughly equivalent

instead they have vastly different performance characteristics

Feel free to create a JIRA issue with suggestions to improve the docstrings.

the vector form is 10x faster

I absolutely will!

@seancorfield Nice, useful blog! Thanks for posting the link earlier.

@seancorfield does this sound right?

The second style, specifying sequence-of-col-names and sequence-of-rows, can
  generate significantly more performant SQL statements, as all rows are
  guaranteed to contain identical columns.

Hi all, got a question about destructuring and namespaced keys... I find this behavior a bit odd:

(let [{:keys [:user/id :company/id]} {:user/id 1 :company/id 2}] id)
=> 2

Is there a good way to alias the two ids in the destructuring?

Closest thing I can see is this, which works fine:

(let [{u :user/id c :company/id} {:user/id 1 :company/id 2}] [u c])
=> [1 2]

Actually, I guess I should say I find the first example "not immediately obvious" since if I think about it as sequential let-bindings it does make sense to me. Anyways, curious if anyone's found a good idiom for this kind of thing

when using ring.adapter.jetty/run-jetty, what is the idiomatic way to set the default charset to utf-8?

it's a jvm flag: -Dfile.encoding=UTF-8, you can probably set this programmatically too

@timgilbert: that's about the best option

ah charset might be something else actually

you can just set it with a ring middleware I guess

@mpenet That does seem to override it; but I'd like it to work with ring.middleware.resource/wrap-resource

So I assumed it would be best set somewhere in jetty

what’s get actually doing when you use it on a list?

(get '(a b c) 1)

I’d expect the behavior to be consistent with vector as an index lookup. I know that’s what nth is for, but just wondering what it’s actually doing

it returns nil

so i’m assuming it’s checking if the data structure is a map and since it isn’t returns nil?

i’m not sure though.

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/PersistentList.java#L327

user=> (.get '(1) 0)
1
user=> (get '(1) 0)
nil

that's.....surprising

waaaa

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/RT.java#L748

looks like it’s calling that under the hood

checks for map, IPersistentSet, and.. if it’s a number and the coll is a string or an array

returns null otherwise

which.. lists aren’t those things? i guess? so it returns nil?

but yeah jr that output is ..

very confusing.

List isn't an array because it does not support random access I suppose

oh yeah.. absolutely makes sense.

maybe the .get call does some conv..ersions? or something?

.get calls nth on a PersistentList

well there you go.

which avoids that call to get in clojure.lang.RT

yeah.

get is for indexed colls

lists are not indexed

the results are undefined if you pass it something that is not an indexed coll

When we have a spec on get, it would tell you this at invocation time (if instrumented)