Enhancement: dynamic recompilation manager ... ?

[jameshfisher]

This is (almost) my first experience with web development using a compiled language. I've become extremely used to being able to just change my code, and when I refresh the page, it runs differently. I do this literally more than once a minute.

Compiling a binary every time I want to see a change, even if compilation is almost instantaneous, is hard work. I don't think it's a fundamental issue with compiled languages, though -- how about if some scheme like the following was followed:

The system is aware of the source from which it is compiled, and tracks those files for changes. When a new HTTP request comes in, if changes to the source have been made, it dies, recompiles, starts again, and then handles the request. There'd be issues if you're storing application state in memory, but ... I don't.

I should say, this management would be done by another binary rather than the app itself. Let's call it runwebgo, and I can call it as with any other binary. And let's say for my application, called blog, I provide a plaintext file called .runwebgo, which contains:

• a list of relative paths to sourcecode files to watch
• a command to execute when recompilation is required (e.g. make)
• a port on which my running app will listen

Now, instead of running make and then ./blog every time, I just run runwebgo in the top level of my app directory. runwebgo then:

• parses my .runwebgo file for the list of files, the command, and the port
• watches all files for updates, setting a changed flag when a file changes
• starts up my app
• runs as a web server (in exactly the same way as a normal web.go app) listening on some odd port (other than the 9999 or 80 which I may have my app configured to)
• every time a request is received, it checks the changed flag. If things have changed, it kills my app, recompiles it, re-runs it. In either case, it then sends on the request to the port of my app.
• when it is killed, it kills my app as well.

It could also observe changes to the .runwebgo file itself, and dynamically update the source list if I resave it.

I imagine creating this would not be too hard or use anything outside the standard library. The upshot IMO is massive: I just run one command and leave it for my whole coding session.

[ghost]

There really is no reason for this to be part of the web.go framework tbh. This sort of stuff belongs to your code environment/IDE.

[jameshfisher]

I generally dislike bulky IDE solutions. I do realise, though, that there's not really anything specific to web.go here apart from the use case. Is there any current generic tool that will watch do what I describe?

[hoisie]

There was a thread about this on the mailing list:
http://groups.google.com/group/golang-nuts/browse_thread/thread/23b7c1b319adedf

In summary - I'd like to have a 'runwebgo' command but the hard part would be figuring out how to compile the web projct. It would need a generic way to compile go sources. This wouldn't be too hard if there was some kind of config file that describes the structure of the project, but it's this kind of scaffolding that I'm trying to avoid.

[tredoe]

Fortunately we already have an automatic Go builder with incremental builds

http://groups.google.com/group/golang-nuts/browse_thread/thread/1cca9738287302
http://code.google.com/p/kylelemons/source/browse/trunk/go/gobuild/README

[hoisie]

There is still no clean way to automatically recompile apps. Closing for now