There are some gotchas with hot swapping, but it's designed and used in production for many years [2].
If somebody knows other languages/systems that do let me know.
1. https://elixir-lang.org/ 2. https://stackoverflow.com/questions/37368376/how-does-erlang...
I've used this technique in multiple games written in Lua, as well as a GUI app written with wxLua, and I can't imagine programming a long-running program in Lua again without it.
There are many caveats like stale module local state but they can be circumvented by designing the program from the start to put such state into a separate module which gets preserved. You do also have to modify your program's code to accommodate hot swapping in some cases but I would say the effort is repaid many times over in time saved not having to restart the program and go all the way back to part you're testing again every time you make a change.
I really wish it were easier to do in popular languages like Python but because of the way it interacts with imports I feel like your only chance to get it right is in the early stages of language design. One time I was wanting to program games in Typescript to take advantage of gradual typing but couldn't figure out an equivalent way to do hot reloading like in Lua, so I went with Lua instead. I feel like if more people knew how much benefit it brings from using a language that supports it we might see more mainstream support in new dynamic languages.
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.
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.
Anyway it’s a very well studied and covered topic in the Java ecosystem as I understand it...
http://blog.ruwan.org/2012/12/dynamic-hot-swap-environment-i...
def print_name(d):
print(d['name'])
d = {'name' : 'hello'}
while True:
print_name(d)
def print_name(d):
print('hello', d['first_name'])
d = {'first_name' : 'there'}
while True:
print_name(d)
;; 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))
{: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}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.
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()
def fn():
d = {'name' : 'there'}
while True:
print(d['name'])
time.sleep(0.5)
[1] http://webcache.googleusercontent.com/search?q=cache:ieBuArS...
(going by https://stackoverflow.com/questions/1840717/achieving-code-s...)
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.
There's an idea in there for a Clojure library :)