@noisesmith / @seancorfield, i understand about the AOT and dependencies, snowball effect… now another question, why is aot so bad, this i still dont understand, what it causes, why ppl avoid it

well, that snowball effect is mutually exclusive - if two libs try to aot, one wins the other breaks

also, there are bugs that can happen in your repl that never happen without aot (things with protocols and gen-class in particular)

even if the two libs are completly different?

right - because if they use other libs (which most do) only one of them will succeed since the libs are aot compiled

and the compiled versions of the same lib are not compatible in most cases - one wins, the other breaks

I see, for deploy / production aot is bad because of the libs, and in dev is bad because of repl

umm... libs shouldn't aot because that breaks everything if two of your libs use a third lib and also aot compile

production or repl

as a smaller problem if you aot your app (apps are better to AOT compile than libs), it causes problems when reloading / repl stuff

I see, lib 1 and lib 2 use cheshire for example, one of them will break if its aot

right

for your app using aot, the problems are smaller, but can happen even if you dev/repl config doesn't use aot - because if you have aot compiled to deploy your app recently, the repl will want to use that instead of the source code on startup

all the app level aot problems can be fixed with workflow discipline and careful program design - but it's a set of problems that go away if you just don't use aot

so the general advice is it's easier to just not use aot unless you absolutely need it to run

I see

And aot just helps with startup performance

A mobile game for example, or a desktop app

I often talk to beginners (or even more experienced devs) that waste hours debugging and the problem was a stale aot class file somewhere

not run-time performance, just startup time, but I think that's what you mean yeah

I understand, server services (apps) startup time doesn’t make that diff

it’s a longrun

@noisesmith a personal question, do you use boot?

I’m testing between boot and lein for that, lein forces a lot the aot

umm... aot is a default if you make an app with lein, but it doesn't force you, it's possible to turn it off by editing project.clj

I don't use boot, I haven't had to - it seems interesting though

I did that, and it keeps showing a warning everytime i use lein uberjar

yeah, that warning is annoying - but it is safe to ignore it

okey, thanks!!

(as long as you know how to start an app that didn't use aot at least 😄 )

newbie here. For the "Situated Software" as in Rich's keynote, what is such a typical Clojure software structure look like? Does it use single atom state? What's the difference between such structure and redux? Is there any good open source project I can learn with?

is there anyting similar to this in clojure ?https://github.com/awaitility/awaitility

core.async can provide you with similar functionality taken that you actually build your system on top of it

How do I use both these libraries 1) https://github.com/juhakaremo/clj-containment-matchers

(is (equal? 1 1))

(is (eventually (= 1 1)

(is (evetually (equal? 1 1) 

Which web framework is easy to use for a beginner?

now that is a question which causes a lot of discussion in Clojure community 🙂

most think that frameworks are not the way to go, one should compose libraries to do your work. Then again, for beginners that is not exactly the easiest way to approach things

that being said, Clojure has actually very few frameworks, most are just libraries

Pedestal has both server and client side stuff available in a framework manner https://github.com/pedestal

I personally haven’t been that interested about that because it is in fact a framework and thus it will ultimately limit my power to do things

but I’ve heard good things about it

@arno http://www.luminusweb.net/ is a good way to get started

right, didn’t even remember Luminus

Anybody ever use datascript on the server?

Any good reason for that?

You may have been thinking of the first alpha version of the pedestal project, which had aspirations of being client-server-framework. The current pedestal service is very comparable to ring, just with a focus on allowing manipulation of the handler stack and enabling async throughout.

OTOH, Ring is "simple" and learning that first lets you build simple web apps without much pain. Then you can add a routing library (e.g., Compojure, Bidi) which, again, are "simple". So you understand how web apps work at a fundamental level.

I think trying to learn a full stack -- ClojureScript on the front end and Clojure on the back end -- all at once is neither "simple" nor "easy" 🙂

i am getting Uncaught Error: Undefined nameToPath for faker also, what's the easiest way to have more debug messages when using cider and figwheel?

stuff is weird, how can i know what is ok to include and what will break?

how should I document a defrecord, since docstrings don't work?

defrecord doesn't create a var, so there's nothing to attach the doc metadata to (I guess clojure could attach it to theconstructor functions it creates, but it doesn't) if nothing else you can make comments - a convention I use is lines starting with ;;; are "documentation comments" for things like that

Hmm. that's a pity. Oh well, I'll stick to the old emacs ;;; convention for now, thanks!

@mseddon another way to do it is to make your own custom constructor (even if it just calls map->Foo inside) and add the documentation to the record there

(defrecord Foo [])                                                              
                                                                                
(defn make-foo                                                                  
  "creates a Foo, which is a record that only exists for example purposes;      
   it implements no protocols or interfaces beyond the default, in fact it      
   is only here so we can have a doc string example"                            
  [m]                                                                           
  (map->Foo m)) 

https://github.com/clojure/clojure/blob/9f277c80258b3d2951128ce26a07c30ad0b47af0/src/clj/clojure/reflect/java.clj#L148 thought I'd look at the source from the docs for those ->'s to see if there was a trick, but it seems that those functions aren't generated from :doc, at least, not as far as I can tell.

but this is probably getting a little OT.. I can make my way, thank's again 🙂