Clojurians Log v2

Good Morning

@tmulvaney: Welcome Thomas. Good hacking with you last night at the Dojo.

morning

@xlevus I’ve only actually written macros twice in practice. Here is one use - https://gist.github.com/chrishowejones/4e8c60e3bcf1573de543

I made one that generated some Compojure routes... but it's taken me a week to work it out

Morning

morning

morning!

Open question: TDD, REPL driven development or hybrid? If hybrid, when to use each?

Haven’t made big projects in clojure yet so I have only been doing REPL driven development

I guess I would add some tests on top for bigger projects, but not as much as with OOP languages ( like I do with python )

I tend to do REPL development first and then add tests later

and when I did C and Java I would write write the tests and the code at the same time

as sometimes I wasn't even sure what the function was supposed to do

RDD and integration tests really work for me with clojure. no unit tests (or not many) and no TDD (well RDD is kinda TDD on steroids really)

but i guess this is a very contextual question too. so depending on the project a lot

RDD = Responsibility-driven design ?????

repl driven development, sry

:simple_smile:

Cheers @agile_geek, I see you've pushed some schema stuffto the social-kata! Was a fun night!

@tmulvaney always enjoy dojos although I can guarantee 'brain fade' when working on a problem.

@agile_geek: TDD, as I still have no idea how to do REPL-DD effectively.

@agile_geek @xlevus : i've got 13 in this 25kloc codebase... no idea whether that is too few or too many. here's my recent fave which cleaned up some truly horrid clojurescript code : https://gist.github.com/mccraigmccraig/f9dc2ced5f9fb696b772

I tend to use integration or functional tests (preferably test first) to quantify the problem, then use REPL driven development with some of the REPL ‘experiments’ preserved after the fact as unit tests. However, I still use TDD for stuff where I just can’t visualise the functions I require up front. I sometimes delete unit tests if I feel tests at the higher level already cover the code enough.

However, I’ve only ever written ‘toy’ projects so hard for me to tell what I would do in a larger code base.

@agile_geek: i tend to do something closer to TDD on libs and closer to RDD on things with a user interface

Even recent toy projects have caught me out with the dynamic typing allowing a whole category of bugs I wouldn’t get in a statically typed system. Having said that I’m not fanatical about static typing and like the speed of development in dynamic typing. I’m just trying to feel my way to a balance of speed vs safety and I’m loath to dismiss TDD from my armoury of techniques just yet.

Before anyone points it out I must look at core.typed sometime.

@agile_geek: prismatic schema is another useful tool here

Social Network kata code from last nights uSwitch Clojure dojo https://github.com/jr0cket/social-network-kata - I've added some docs and tried to capture some of our thinking process as comments too... #pullrequestswelcome

cool :simple_smile:

jr0cket: when you showed your code yesterday you had some special characters displayed, why/how are you doing this ? 😄

@agile_geek: we tried to add core.typed recently to some existing code and found it quite painful, not straight forward unfortunately

@quentin: the "special" characters are substituted by Emacs. I use https://github.com/overtone/emacs-live as my base configuration and it swaps (fn ..) with a lambda symbol, #( .. ) with a stylised f and #{ ... } with a set character

@agile_geek: since you mentioned it last night, I've seen a few more examples of defrecord (in the "Mastering Clojure Data Analysis" book). Do you think that defrecord can add enough "type safety" in many cases ?

thanks jr0cket :simple_smile:

@mccraigmccraig: yep. Used Schema a bit.

@quentin: @jr0cket i really liked that stuff, went crazy on it a bit:

emacs-lisp

;; pretty symbols
(global-prettify-symbols-mode 1)

(add-hook 'clojure-mode-hook
          (lambda ()
            (push '(">=" .      ?≥) prettify-symbols-alist)
            (push '("<=" .      ?≤) prettify-symbols-alist)
            (push '("partial" . ?π) prettify-symbols-alist)
            (push '("defn" .    ?⇒) prettify-symbols-alist)
            (push '("defn-" .   ?⇛) prettify-symbols-alist)
            (push '("atom" .    ?α) prettify-symbols-alist)
            (push '("nil" .     ?Ø) prettify-symbols-alist)
            (push '("->" .      ?→) prettify-symbols-alist)
            (push '("->>" .     ?⇉) prettify-symbols-alist)
            (push '("reduce"    ?Σ) prettify-symbols-alist)
            (push '("map"       ?↦) prettify-symbols-alist)
            (push '("false"     ?ғ) prettify-symbols-alist)
            (push '("true"      ?τ) prettify-symbols-alist)
            (push '("or"        ?∨) prettify-symbols-alist)
            (push '("and"       ?∧) prettify-symbols-alist)
            (push '("not"       ?¬) prettify-symbols-alist)))

my config for all kind of prettifing

oh my

but i switched that off because it messes with how emacs counts characters in buffers

and it also puzzles anyone looking at your screen (which is both good and bad i guess 😉 )

so if you go crazy on this stuff that is effectively breakes stuff in clj-refactor for example

@benedek: bit too mathy for me to be honest

as column counts will differ in the buffer and in the file...

i said i went crazy 😉 and not using prettifying at all nowadays...

happens to the best of us 😉

i think @bozhidar has a blog post about it btw

@thomas: indeed 😉

@jr0cket: not sure record helps with ‘type safety’ but it does establish a contract. Used with Schema it looks like a way forward.

it really makes your code look concise tho… (loved the arrows instead of defn, defn-)

looking to the future : https://github.com/LuxLang/lux

I really hope the future does not involve the JVM.

or maybe only involves it as one of several supported backends...

i was looking at this https://github.com/cljsinfo/api-refs/tree/catalog earlier which makes it clear just how much of a massive effort ClojureScript is (in the number of functions re-implemented for ClojureScript)

@martintrojer: I have a bit of a love/hate relationship with the JVM...

getting the eco system is nice for instance

and all the work that has gone into the JIT etc.

yeah, lots of work. still not very good.

Re; JVM — Brian Goetz conj talk was a tiny bit inspirational. Value types would be a nice step forward, just a decade or 2 too late.

@mccraigmccraig: https://github.com/pixie-lang/pixie is quite cool and has its own vm/jit

Sure, Baldridge is a cool guy. Will be interesting to follow pixie

tmulvaney: oh, i hadn't seen that... though the thing i was liking about lux is the static type system. clojure gets many things right, but i keep on wanting (sane) static validation

(where haskell is at the 'sane' end of the spectrum and scala umm not)

core.typed can be what you are looking for

writing a blog about core.typed atm. well, when I say writing I mean doing some research. well, when I say research I mean toying around in the REPL.

All these languages are very interesting but I often get business people wondering why as an industry we can’t settle on a small subset rather than keep reinventing ourselves every 5 mins. I know we have to keep moving to make best use of advances in technology and approach but they have a point.

agile_geek: agreed. especially when all we are doing is hill climbing. New languages are OK, but they should explore (radically) different ideas.

@martintrojer: yeah, i'll try core.typed on the next greenfield project i do ... it looks difficult to retro-fit

mccraigmccraig: retrofitting is on my list to tackle in the post

@martintrojer I'd be interested in that post as core.typed is something I'd like to look at.

@agile_geek: but which subset ? and why would software make itself static when business processes are always being reinvented ?

@martintrojer: me too

@mccraigmccraig if I knew the answer to that I'd be rich and famous!

RE pixie; can be the answer to the problem of writing shell scripts in a clojure-like language.

if he gets the FFI story right (which he might have already) hooking into existing webserver libraries etc could be interesting for writing small REST apis etc.

well he's using libuv for dealing with IO which is what node uses. I've written a very poor webserver built on top of pixies tcp streams which was quite fun.

I think writing pixie FFI bindings for joyents http-parser could be an interesting project