Presently, all the source level debuggers in the market has limited capability of 
 debugging which affects the process timings and synchronization. this may limit the use 
 of debuggers to simulated environment. 
 
 for example: when process/thread being debugged is brought under control of a debugger, the process will be stopped.
              The moment the process is stopped by debugger, brings some uncomfortness in terms of timings and synchronization for the inferior/debugee 
              and other processes/threads, which depend on inferior/debugee's response. 
              
              So, current debuggers stop the process and may not be suitable to inspect data in field, because the moment it stops the process
              the services in the running(live) fields becomes unusable for some time and other depedent thread/processes may also get affected, and as a  
              result million of users, who are taking services.                
              
 My proposal is;
 
 providing capability of debuggers which never stops the process, but still user will be able to inspect 
 (here the term 'inspect' is of major importance and vital) the data and to collect the trace.
 
 well, to reiterate, I am talking about keeping all the threads/processes running even if they are under control of debugger.
 for e.g. gdb (well known linux debugger, till 7.0, it used to stop all the threads/process. even in 7.0 non-stop thread debugging stop one thread which    
 user needs to debug.)  
 
 
 but my idea is going one step further, and providing capability which keeps all the threads/process running all the time, and still user will be able to 
 collect some data, in this way we make sure that processes/thread timings and synchronization interests are not compromised.
 
 
 of course this type of debugging technique to be used and more suitable in actual field only, where it adds value and provide some sort of business sense 
 in terms of tracing and debugging.
 
 
 Apart from that it also eliminates possibility of user making any (human error) mistake of keeping the process/thread on hold while inspecting 
 (for e.g. he has written 'expect' script, to make it automated, but did some mistake, and also just having script make the things very much static).