Hello 🙂 Typically people re-evaluate modified code by sending code to the repl from their editor (https://clojure.org/guides/repl/enhancing_your_repl_workflow#editor-integrations) For a webserver, there are a few tricks to make the server pick up the changes, like referring to your handler function using var syntax #'handler . Basically, as you write functions or modify existing ones, place your cursor on the form and hit a key binding to evaluate the form in the repl. There is also the "reloaded" workflow, and libraries that implement the pattern (e.g. integrant). If you are new to Clojure, I highly recommend getting comfortable sending forms to the repl from your editor for evaluation.

@U052PH695 thank you for that. I'm already using my editor integration, it just shows not perfectly, how the image is placed in relation to the text or something, for that i need the browser... Im gonna give a hit to the var syntax, maybe this helps, thank you again ❤️

With the var syntax, after you re-define your handler function the server should use the new code. You still have to remember to re-evaluate the handler function (and any changed functions it depends on) to see your changes

Oh, you have join false, so the main thread isnt waiting for jetty to exit, so main thread stops after starting jetty, and depending the jvm may just exit after that

So you want join true

I think there may have been some issue with my Java cache, because I restarted my host machine and tried again and everything works. Thanks @U0NCTKEV8 for the replies

Complicated

It is just a regular channel, so after launching the go block you can hand it off to some other code that writes other values to it

But that is a crazy thing to do

But the only thing the go block does with the channel is write the return value of the go block (if the return is not nil) then close the channel

When I write this I get nil as response.

(try
   (/ 10 0)
   (catch Exception e
     )) 

(defn my-try-catch
   [f]
   (try
     f
     (catch Exception e
       )))

 (my-try-catch (/ 10 0))

every function must evaluate it's arguments before the call. so, at first (\ 10 0) called throwing an exception that you see.

that is one of the uses of macros, to control argument evaluation. So for that you would have to use a macro like this :

(defmacro my-try-catch
  [& body]
  `(try
     ~@body
     (catch Exception e#)))

(my-try-catch (/ 10 0))

Thank you for the answers 🙂 I am not experienced with macros and I prefer to avoid it if I can, so I tried it with higher order functions.

(defn my-try-catch
    [f]
    (try
      (f)
      (catch Exception e
        ;; log exception and return nil
        )))

  (my-try-catch (fn [] (/ 10 0)))

Hey, yeah, macros take some time to wrap your head around, but this are good opportunities to start playing with them. A Clojure macro is just a normal Clojure function, that will be called at compile time with the arguments without being evaluated. So if my-try-catch is a function, it will be called with the result of (/ 10 0), while if it is a macro it will be called with a list containing the / symbol, the 10 and the 0. Whatever the my-try-catch macro returns will be used as code instead of (my-try-catch (/ 10 0)) You can also write a similar macro without all the fancy symbols, which could look like this :

(defmacro my-try-catch
  [form]
  (list
   'try
   form
   '(catch Exception e
      )))

=> (macroexpand '(my-try-catch (/ 10 0)))

(try (/ 10 0) (catch Exception e))

Wow! Thanks a lot for taking your time to explain 🙂 I will definitely try them out. Are there any pitfalls one has to be aware of while using macros?

nothing special! they are just functions, they get the code as argument (just data) and the returned data will be used as code instead of the original call. Learning about the backquote(`) is not mandatory for macros, but pretty useful since you can use them as "templates" when generating code

I'd say using lazy-seq directly is not necessary in this case, but it's a possible solution... if you make the sequence (trying not to give too much away because I'm not sure how much spoiling you do or don't want), you can wrap that in a one-arg function and take from that sequence

you might also like a function like iterate

Thanks. iterate provided a Fibonacci sample that was easier to adapt for http://4clojure.org.

the really clever fib lazy sequences tend to implicitly rely on the fact that top level defs are mutable reference cells that are deref'ed every time a function is invoked, and lazy sequences are constructed out of thunks (functions)

so generally non-starters for producing anything other than a def'ed infinite sequence, not very usefl

I was wondering why this problem was in the Easy category.