Making an .exe that executes source file inside itself.

[IntegratedDimensions]

On Wednesday, 25 April 2018 at 19:19:58 UTC, BoQsc wrote:
> So there has been idea I've got for around few months now: 
> making a software which executable would contain a source file.
> A software that anyone could modify by opening an executable 
> and quickly change a few lines of it, rerun an executable, see 
> the changes.
>
> Could this be easily possible with D language, considering that 
> sources files can be ran without long slow compilation process?

I had a similar idea a few months ago too, coincidence?

The idea is that all apps have the source code embedded so that 
they can be debugged and modified by the user at will. Each app 
has a built in IDE and debugger(or can trigger an external one 
for space).

When an error occurs it will jump to the debugger for debugging 
purposes. If some functionality is to be modified(e.g., change 
the size of a button or add some new feature) the user can 
trigger the IDE(hot key) to proceed.

The point of having it all self contained is to allow future 
revision and debugging without having to worry about version 
issues. The point of the debugging is so the user can fix bugs 
that plague software. While on the whole most software may work 
for most users, it is very annoying when some minor bug prevents 
a program from working for a specific user. Many more people know 
how to program than ever and it will only become more and more 
common.

Also, with such capabilities, the user can add additional 
functionality. It is very annoying when programs don't support 
simple stuff. A few lines of code could make the program much 
more effective for a user that wants to do something that was not 
thought of if they could just add it. e.g., even just display 
something, change the location of a widget, or modify how a text 
file is read so it can support a new format.

One can argue that platforms such as Linux make this easy... but 
only marginally. If one get actually get the code to compile 
without having to waste many hours, one must also generally sift 
through the code to find the relevant parts then try and 
understand them. Usually because of the trial and error process 
is long this generally is a deterrent for "normal" people with 
"normal" lives.

If apps are properly structured with such goals in mind then it 
would be of great benefit, although only a few of us like you and 
me have the wherewithal to extrapolate out.

It would not be difficult to do(it is more about organization 
than about technological problem solving). With proper ide 
design, debugger, and such, one could make app writing self 
contained, so to speak. That is, the IDE and debugger are used 
directly to write the program instead of using the traditional 
methods such as vim, emacs, visual studio, coedit, etc.

What is packaged in an binary are the

IDE
Debugger
Profiling
Source Code(with history, VCS included)
Compiled Code(possibly optimized version)
Debugging Data
Scripting

Generally, without debugging, the executable just runs the 
compiled code as if it were a normal app. When triggered, the 
ide/debugger can be brought up that takes over and displays the 
desired source code(triggers can be used).

I believe the main issues for proper development would be the 
ability for quick code replacement(hot swapping, injection, etc) 
which is tricky since some code would require a full restart 
which will slow things down. Most of the other programs are just 
gluing everything together and providing certain mechanisms that 
allow for robustness such as being able to replace the IDE or 
debugger, extract the source code for repackaging.

While it would be time consuming to implement well it would be 
very useful. There are many many times I have used programs that 
simply do not function correctly or are missing simple 
functionality that would take me a just a few minutes to write a 
few lines of code to fix.  Having the above would make it 
possible to do. One could also then "upload" 
patches/fixes/enhancements to the cloud or download others. This 
way people can tailor applications to their own use rather than 
being stuck with what the developers(which generally are somewhat 
clueless as their main goal is to ship the product rather than 
provide all the functionality their users want).