Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

C and C++ Hot-Reload/Live Coding

liveplusplus.tech

Post reply on HN
Print view View original

51–60 of 102 posts

Re: C and C++ Hot-Reload/Live Coding

#51

Post by sigmoid10 »

moelf wrote: post #50
Jeaye wrote: post #35

Folks interested in this should absolutely look at the open source Cling project, which uses Clang/LLVM to JIT compile C++ in-process. https://github.com/root-project/cling I'm using Cling, as part of jank, a native Clojure dialect on LLVM, with C++ interop. This allows me to have truly interactive, dynamic programming, while still reaching into native code. jank source compiles to C++, which is then JIT compiled by…

My personal experience with ROOT REPL is that it's quite stateful, some error may make you want to restart the session I avoid it for anything longer than a few minutes of use

This. I haven't used it for a while, but my experience is that this whole idea is not worth the trouble. If you want to rapidly design and test algorithms in a JIT environment, just use Python. It's designed for that. You can always port it to c++ in the end if performance is an issue.

Re: C and C++ Hot-Reload/Live Coding

#52

Post by LispSporks22 »

mananaysiempre wrote: post #24
kleiba wrote: post #18

In one of the earlier episodes of the Handmade Hero series, Casey Muratori writes a hot-reloading functionality for C from scratch in about an hour (while giving detailed explanations of what he's doing). The following two episodes then improve upon the initial results. https://www.youtube.com/watch?v=WMSBRk5WG58

On one hand, I appreciate Muratori showing that loading code into your program dynamically isn’t actually difficult. On the other, the hard part of general hot reloading on systems that have tried it (from Smalltalk to VC++ Edit-and-Continue) is migrating obsolete state—or at least reliably telling the user when you can’t, so as to avoid leaving them to debug a mad world that could never be encountered in a fresh run…

> migrating obsolete state

Do you mean like in Lisp with update-instance-with-different-class for example?

https://www.lispworks.com/documentation/HyperSpec/Body/f_upd...

Re: C and C++ Hot-Reload/Live Coding

#53

Post by Jeaye »

sigmoid10 wrote: post #51
moelf wrote: post #50

Earlier quoted context omitted.

My personal experience with ROOT REPL is that it's quite stateful, some error may make you want to restart the session I avoid it for anything longer than a few minutes of use

This. I haven't used it for a while, but my experience is that this whole idea is not worth the trouble. If you want to rapidly design and test algorithms in a JIT environment, just use Python. It's designed for that. You can always port it to c++ in the end if performance is an issue.

I understand that frustration. Fortunately, Clojure (and jank) gets around this entirely. Functions can be redefined at any time, even with different signatures, globals as well. References to the will stay intact and will use the latest value; this is also thread-safe.

Ultimately, this isn't something Cling needs to worry about. You can have your cake and eat it, too. If that sounds too good to be true, know that it's how Clojure devs write all programs. We spin up the process and then send code to it from our editors, without needing to tear it down.

jank gives you this, in C++ land, including support for inline C++ within your Clojure code. I'll have a lot more demos coming out this year, but you can also check out the jank blog or my talks at ROOT's compiler research group and Clojure Conj 2023.

Re: C and C++ Hot-Reload/Live Coding

#54

Post by MuffinFlavored »

vodou wrote: post #20

Maybe I'm just old and grumpy, but the subscription business model just puts me off. Nowadays when I read about some development tool (or just any product), I start with the price page. If there are only subscriptions available I stop reading and go on with my life.

Devil's advocate: You aren't their target customer then?

Re: C and C++ Hot-Reload/Live Coding

#55

Post by MuffinFlavored »

tsmeets wrote: post #40

You don't need anything complicated for this. All you need is to compile your code to a shared library that exports an 'update' method. See https://github.com/TomSmeets/quest-for-nothing/blob/master/a... You have to be careful with global variables however, they will get cleared to zero when the code is reloaded. To solve this either don't use globals or just restore them on reload.

Any other "stateful" issues you've ran into?

Re: C and C++ Hot-Reload/Live Coding

#56

Post by donadigo »

PhilipRoman wrote: post #33

I'm a fan of the opposite approach - serializing the program's state and launching a new instance which reads it. For one particular application I just had it keep all of it's useful state in /dev/shm (mmapped as a struct), double buffering it on every iteration of the main event loop. Of course that doesn't scale too well if you have dynamic allocations. This also has the advantage of not requiring platform specific…

Interesting approach. Was it enough for your use case despite being quite cumbersome if you end up needing to save a bunch of different more complex instances? I mean, I imagine most dynamic objects that are the real state you'd care about will probably be allocated somewhere on the heap and be referenced from lists or pointer types. I guess this would work best for POD types like program settings and the like, so I'm curious about your setup there.

Re: C and C++ Hot-Reload/Live Coding

#57

Post by johnnyanmac »

MuffinFlavored wrote: post #54
vodou wrote: post #20

Maybe I'm just old and grumpy, but the subscription business model just puts me off. Nowadays when I read about some development tool (or just any product), I start with the price page. If there are only subscriptions available I stop reading and go on with my life.

Devil's advocate: You aren't their target customer then?

Yeah. Sad fact is a lot of this stuff isn't targeting individual devs. It's targeting small-medium sized companies, who are fine buying productivity so they can create more value than they pay.

Maybe a few larger companies as well, because those subscriptions tend to come with support, and larger companies love to throw maintenance to non-employees. But if they cared enough about not having a subscription, they'd make it themselves.

Re: C and C++ Hot-Reload/Live Coding

#58

Post by jheruty »

el_oni wrote: post #27
mananaysiempre wrote: post #24

Earlier quoted context omitted.

On one hand, I appreciate Muratori showing that loading code into your program dynamically isn’t actually difficult. On the other, the hard part of general hot reloading on systems that have tried it (from Smalltalk to VC++ Edit-and-Continue) is migrating obsolete state—or at least reliably telling the user when you can’t, so as to avoid leaving them to debug a mad world that could never be encountered in a fresh run…

There is a tsoding daily video with hot code reloading in C [0]. He dicusses techniques for this. one of which is a "migration" approach, similar to database migrations. Where, for example, you have a version number in your struct. and a function for migrating from an old version to a new version. I don't think he implements it in that video though. [0] https://www.youtube.com/watch?v=Y57ruDOwH1g&t=15s

I experimented with hot-reloadable C++ a while back. https://github.com/jheruty/hscpp.git

Video for how it works: https://www.youtube.com/watch?v=pjGngeKgni8

To migrate from one class version to another, I found the easiest way was to provide a callback method in the constructor where one could save the state from the old class, and read it into the new class. For example: https://github.com/jheruty/hscpp/blob/master/examples/simple...

Ultimately though the limitations of hot-swapping this way limits its usefulness. My understanding is that liveplusplus is much more full-featured.

Re: C and C++ Hot-Reload/Live Coding

#59

Post by macintux »

cryptonector wrote: post #47
mjburgess wrote: post #6

fyi, "hot reload" is a native part of every operating system (consider, even trivially, forking or https://en.wikipedia.org/wiki/Dynamic_loading ). It's a sign of how bad developer tooling has been that live reload is sold as an add-on feature. DX seems always to see-saw between bill gate's c. 1990 demo of VB, and the compile-time speeds of a N' Wirth. At a guess, when the internet happened, all DX had to be thrown a…

fork() doesn't hot reload much of anything. exec() doesn't hot reload either. Dynamic loading doesn't hot reload either, more like hot load. Debuggers might hot-patch code to insert breakpoints, but that's not the same thing as replacing running code. Sure, the debugger might execute scripts you associate with breakpoints, but that's also not exactly the same thing as replacing the running code. Mind you, debuggers d…

> ... a) single-threaded

Well, one counter-example: Erlang.

But Erlang is typically the exception to any rule.

Re: C and C++ Hot-Reload/Live Coding

#60

Post by cryptonector »

macintux wrote: post #59
cryptonector wrote: post #47

Earlier quoted context omitted.

fork() doesn't hot reload much of anything. exec() doesn't hot reload either. Dynamic loading doesn't hot reload either, more like hot load. Debuggers might hot-patch code to insert breakpoints, but that's not the same thing as replacing running code. Sure, the debugger might execute scripts you associate with breakpoints, but that's also not exactly the same thing as replacing the running code. Mind you, debuggers d…

> ... a) single-threaded Well, one counter-example: Erlang. But Erlang is typically the exception to any rule.

Shared-nothing threading is definitely easier to deal with in hot-reloading, and I should have thought to mention that.
Post reply on HN