Hacker News Reader

Comment by dig1 | Hacker News Reader

> If somebody knows other languages/systems that do let me know.

Clojure can do this via namespace live reload. ClojureScript is already doing this inside figwheel [1] environment. CommonLisp had this since dawn of time. Kawa [2] can do it, but because it aggressively optimize the code, you need to be careful. Racket can do it as well [3].

[1] https://github.com/bhauman/lein-figwheel

[2] https://www.gnu.org/software/kawa/

[3] https://github.com/tonyg/racket-reloadable/tree/master#readm...

EDIT: added Kawa and Racket.

View on HN

Java with DCEVM or OSGi. This was originally a big OSGi selling point if I recall correctly though I’ve never seen it successfully implemented - though maybe in the Eclipse IDE?

Anyway it’s a very well studied and covered topic in the Java ecosystem as I understand it...

http://ssw.jku.at/dcevm/

http://blog.ruwan.org/2012/12/dynamic-hot-swap-environment-i...

https://www.jrebel.com/blog/java-hotswap-guide

The languages you mention can't update data in flight, which is something Erlang can. Suppose you have the following code running in a thread:

    def print_name(d):
        print(d['name'])
    d = {'name' : 'hello'}
    while True:
        print_name(d)

Now you hot hot-swap it while the while-loop is running:

    def print_name(d):
        print('hello', d['first_name'])
    d = {'first_name' : 'there'}
    while True:
        print_name(d)

Erlang can do this. No other language that I'm aware of can.

Clojure has all sorts of facilities to do that (atoms, agents or refs). You can even listen for changes [1] and compare old and new values.

[1] https://clojuredocs.org/clojure.core/add-watch

Interesting, I didn't know that. I don't understand how the function you link to can be used to accomplish that. Can you give me an example?

Sure; here is example with atom:

    ;; define a map
    (def myvar (atom {:foo 1}))
    
    ;; add watcher for 'myvar'; it will call anonymous
    ;; function and set old-state with previous value and new-state
    ;; with new value, when 'myvar' was changed
    (add-watch myvar :dummy 
      (fn [_ _ old-state new-state]
        (println "changed! - old: " old-state " new: " new-state)))
    
    ;; Run separate thread and and update :foo value to 2, after 6 seconds.
    ;; No scheduling is necessary, this is so it can be evaluated in REPL easily.
    (future
      (Thread/sleep 6000)
      (swap! myvar assoc :foo 2))
    
    ;; Infinite loop. Sleep for 0.5 seconds just for printing purposes.
    (loop []
      (println @myvar)
      (Thread/sleep 500)
      (recur))

and you will see output like this:

    {:foo 1}
    {:foo 1}
    {:foo 1}
    {:foo 1}
    {:foo 1}
    {:foo 1}
    {:foo 1}
    {:foo 1}
    changed! - old:  {:foo 1}  new:  {:foo 2}
    {:foo 2}
    {:foo 2}
    {:foo 2}
    {:foo 2}
    {:foo 2}
    {:foo 2}

That is an example of thread messaging - not hot-swapping. Had myvar been local to the thread it wouldn't have worked.

I used different thread just for printing/add-watch purposes.

But, using myvar or your-like example (hot loading function) in the same thread works without any problems as well - put function in a loop, change function body and reload namespace where myvar/function exists - loop will pick that up instantly.

In your example, you modified the assoc while another thread was accessing it. That is a standard feature of languages with threading support and is not impressive.

Let me give you a clearer example than my first one:

    def fn():
        d = {'name' : 'hello'}
        while True:
            print(d['name'])
    threading.Thread(target=fn).run()

This causes a thread to be started which prints "hello" indefinitely. Clojure cannot, while the thread is running, change the execution to, say:

    def fn():
        d = {'name' : 'there'}
        while True:
            print(d['name'])
            time.sleep(0.5)

Clojure cannot change the value of the local variable d because it has no reference to it. Clojure cannot add the line time.sleep(0.5) to the loop because it has no facility for "upgrading" running threads.

Check [1] to see what I'm talking about. I'd suggest you to investigate more before making such bold claims.

[1] http://webcache.googleusercontent.com/search?q=cache:ieBuArS...

Reading up on the Erlang system, it doesn't upgrade function-local state this way either. It relies on a convention where this state is stored externally to the function by the gen_server framework and passed in, right?

(going by https://stackoverflow.com/questions/1840717/achieving-code-s...)

Yes and no. Like everything in Erlang, hot-swapping relies on code being structured as servers that responds to messages. In this case, the VM sends a message to the process telling it about the code upgrade. The process has to handle this message "manually" and do what it needs with it. For example, changing its internal state or updating database schema if it uses external storage.

But you don't have to use the gen_server framework to accomplish this. It's perfectly fine (but not recommended as there are lots of details you want to get right) to write your own code for handling hot-swapping. See http://erlang.org/documentation/doc-4.9.1/doc/design_princip... for some details on server principles.

Immutability in combination with Erlang's process centric view is what makes it possible.

Thanks for the explanation.

There's an idea in there for a Clojure library :)

i believe smalltalk can do this as well.

there are also lesser known languages such as pike. although pike doesn't do hotswapping of actual objects but only allows the hotswapping of the compiled classes used to instantiate new objects. this works well enough on webservers where new objects are created for every request, and only live as long as the request is processed.

there is a platform called open-steam that emulates hotswapping by using proxy objects. when i reference an object, i actually get a proxy, that then references the real object. when i update the code, then the proxy gets updated to the new real object, and for me it looks like the object i am referencing has been hotswapped.

Tcl as well.

Reply on news.ycombinator.com