Abstract: Embodiments of the invention provide a method, apparatus, and program product to verify a program that includes a plurality of sections with a computing system that is configured to process a plurality of threads of execution. The method comprises verifying and executing a first section of the program utilizing a first thread of execution in response to activation of the program and determining a second section of the program to execute subsequent to the first section. The method further comprises verifying the second section utilizing a second thread of execution in parallel with the execution of the first section. Another embodiment of the invention provides a method of compiling program that includes program code by grouping the program code into sections based upon the execution time of the program code and based upon which program code is most commonly executed.

Abstract: A method and a system for displaying an image based on texts in the image are provided. The method of the invention for displaying the image includes: a text extracting step, extracting text regions in the image to be displayed; a text occupancy amount calculating step, calculating occupancy amount of the text in said image; a comparing step, comparing the calculated occupancy amount with a predetermined threshold; a display step, displaying the image in real size of the image if said occupancy amount exceeds said predetermined threshold. It is achieved to display the image to the user in a manner of satisfying the viewing aim of the user, and unnecessary load of the computer system is avoided.

Abstract: A method, computer-readable storage medium, and computer system are provided. In an embodiment, a defect is detected in a product. In response to detecting the defect in the product, a part is created that describes the state of execution of the product at a time that the defect was detected. In response to creating the part that describes state of the execution of the product at the time that the defect was detected, authority is granted to access the part to a first user who is responsible for fixing the defect.

Abstract: A computing system includes computer memory of a number of different memory types. An application program compiled for execution on the computing system controls access to a field of a record in the computer memory of the computing system by defining a record that includes one or more fields, the one or more fields including a restricted field having a specification of restricted accessibility when the restricted field is allocated in a particular memory type; allocating an instance of the record in memory of the particular memory type; and denying each attempted access of the restricted field while the record is allocated in the particular memory type.

Abstract: A computing system includes a number of memory modules and temperature sensors. Each temperature sensor measures a temperature of a memory module. In such a computing system a garbage collector during garbage collection, determines whether a temperature measurement of a temperature sensor indicates that a memory module is overheated and, if a temperature measurement of a temperature sensor indicates a memory module is overheated, the garbage collector reallocates one or more active memory regions on the overheated memory module to a non-overheated memory module. Reallocating the active memory regions includes copying contents of the active memory regions from the overheated memory module to the non-overheated memory module.

Abstract: A debugger allows a programmer to select the granularity of a line step function. Using a debugger step statement, the programmer can specify line step, statement step, or automatic selection. When the user specifies line step in the debugger statement, the debugger functions in true line step mode, where a line of source code is executed for each step. When the user specifies statement step in the debugger statement, the debugger functions in statement step mode, where a statement is executed for each step. When the user specifies automatic selection in the debugger statement, the program is analyzed, and a decision regarding whether to use line step or statement step is made based on the characteristics of the program and based on user-specified selection criteria. In this manner the function of the debugger when line stepping can vary according to the programmer's needs.

Abstract: In an embodiment, in response to reading a declaration of a function that specifies a name of the function and a type of memory on which the function operates, the name of the function, a pointer to the function, and the type are saved to a template. In response to reading a call statement that specifies the name of the function and an identifier of an object, first code is generated. The first code, when executed, reads the pointer to the function from a virtual function table pointed to by the object, finds an entry in the virtual function table that represents the function, and reads the pointer from the entry in the virtual function table. The call statement, when executed, requests a call of the function. Second code is generated that, when executed, calls the function using the pointer read from the virtual function table.

Abstract: Administering thermal distribution among memory modules in a computing system that includes temperature sensors, where each temperature sensor measures temperature of a memory module and thermal distribution is effected by: determining, in real-time by a user-level application in dependence upon the temperature measurements of the temperature sensors, whether a memory module is overheated; if a memory module is overheated and if a current call stack frame is stored on the overheated memory module, increasing, by the user-level application, a size of the current call stack frame to fill remaining available memory space on the overheated memory module, ensuring a subsequent call stack frame is stored on a different memory module.

Abstract: Thermal-aware source code compilation including: receiving, by a compiler, an identification of a target computing system, the identification of the target computing system specifying temperature sensors that measure temperature of a memory module; compiling the source code into an executable application including inserting in the executable application computer program instructions for thermal-aware execution, the computer program instructions, when executed on the target computing system, carry out the steps of: retrieving temperature measurements of one or more of the target computing system's temperature sensors; determining, in real-time in dependence upon the temperature measurements, whether a memory module is overheated; if a memory module is overheated, entering a thermal-aware execution state including, for each memory allocation in the executable application, allocating memory on a different memory module than the overheated memory module; and upon the temperature sensors indicating the memory modu

Abstract: Methods, apparatuses, and computer program products for real-time temperature sensitive machine level code compilation and execution are provided. Embodiments include compiling and executing, by a just-in-time (JIT) compiler, machine level code; during execution of the machine level code, determining, by the JIT compiler, an execution temperature for the machine level code, including reading temperature measurements from one or more processor temperature sensors; based on the determined execution temperature, identifying, by the JIT compiler, a portion of the machine level code that, when executed, caused temperature measurements of one or more processor temperature sensors to exceed a predetermined threshold temperature; recompiling, by the JIT compiler, the machine level code including modifying the identified portion to generate a new execution temperature that is lower than the previously determined execution temperature; and executing, by the JIT compiler, the recompiled machine level code.

Abstract: Software development with information describing preceding execution of a debuggable program includes receiving, by a debugger from a compiler, a copy of a debuggable program, the debuggable program including one or more phantom breakpoints not encountered during a previous execution of the debuggable program, each phantom breakpoint inserted at a separate line of source code, phantom breakpoints encountered in a previous execution of the debuggable program being removed during the previous execution and not included in the copy of the debuggable program; executing, by the debugger, the copy of the debuggable program; upon each encounter of a breakpoint, determining, by the debugger, whether the encountered breakpoint is a phantom breakpoint; and if the encountered breakpoint is a phantom breakpoint, issuing, by the debugger, a warning indicating a point of straying execution.

Abstract: Inserting, at debuggee source code lines, a breakpoint and executing. For each breakpoint encounter until exiting: encountering and removing the breakpoint, incrementing a first counter value, and resuming execution. Exiting includes saving the first counter value, a state of the call stack, and an exit location. In a second debug session, preparing the debuggee to resume from the exit location. Inserting, at the debuggee source code lines, a breakpoint and executing the debuggee. For each breakpoint encounter until a second counter value matches the first: encountering and removing the breakpoint, incrementing the second counter value, and resuming execution. When the first and second counter values match: inserting an exit location breakpoint at the exit location, executing the debuggee until encountering the exit location breakpoint, and providing the user control to resume debugging from the exit location only if the present state of the call stack matches the saved state.

Abstract: Integrating compiler warnings into a debug session including: receiving, by a debugger for a debug session of a debuggee from a compiler, compiled source code for execution and compiler warning data describing one or more compiler warnings generated at compile time of the debuggee, each compiler warning resulting from a source code variable statement in the debuggee source code; receiving, by the debugger, a request to evaluate a variable; determining, from the compiler warning data, whether evaluating the variable is dependent upon a source code variable statement resulting in a compiler warning; and, if evaluating the variable is dependent upon a source code variable statement resulting in a compiler warning, returning, by the debugger responsive to the request along with a result of the evaluation, a compiler warning indicator.

Abstract: Software debugging including: inserting, by a compiler compiling source code into a debuggable program, a phantom breakpoint at one or more lines of source code; including in the program; executing the program including encountering phantom breakpoints and removing each encountered phantom breakpoint; creating, upon exiting execution, a copy of the program that includes only phantom breakpoints not encountered during execution; providing the copy to a debugger; identifying, by the debugger, source code lines of the copy that do not include a phantom breakpoint; inserting an executed phantom breakpoint at the identified lines of the copy; executing the copy of the debuggable program including removing encountered breakpoints; and, after exiting execution of the copy, determining whether execution of the copy matches the execution of the debuggable program including, determining that the executions do not match if any phantom breakpoints were removed from the copy or any executed phantom breakpoint remains in t

Abstract: In a distributed system that includes a debug server and debug clients coupled for data communications through a data communications network, where the debug server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes receiving, by the debug server from the debug clients, application-level messages including receiving, from a requesting debug client, a request to establish a private debug session of the debuggee; routing, by the message router, the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including forwarding, to the back-end debugger, the request to establish a private debug session of the debuggee; and; and returning, by the debug server to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results, including establishing the private debug session of the debuggee for the requesting debug client.

Abstract: User-specific software debugging with user-specific step commands that includes: receiving a command to step execution to a source code module associated with a user; identifying routines in a call stack associated with the user; inserting, for each identified routine, a breakpoint at each source code line of the routine; inserting, for each source code module associated with the user and not in the call stack, a breakpoint at an entry point of the source code module; and executing the debuggee until the debuggee encounters one of the inserted breakpoints thereby halting execution of the debuggee. User-specific debugging with user-specific DLL load processing modes including: receiving a selection of a user-specific DLL processing mode; upon loading a DLL, retrieving a user identification; determining whether the DLL is associated with the user; and processing the DLL in accordance with user-specific DLL processing mode only if the DLL is associated with the user.

Abstract: Embodiments of the invention provide debugging techniques for multithreaded programs. For example, a debugger may reduce the time required to release inactive threads that hold resources needed by an active thread. For example, if a timer expires before a line of code finishes executing, the debugger assumes that the active thread requires a resource locked by an inactive thread and releases other threads. During subsequent execution of the line of code, the debugger reduces the timer length of the timer. In doing so, inactive threads are released sooner, thereby reducing the wait time a user experiences when debugging lines of code.

Abstract: Embodiments of the present invention provide a method, system and article of manufacture for adjusting a language model within a voice recognition system, based on text received from an external application. The external application may supply text representing the words of one participant to a text-based conversation. n such a case, changes may be made to a language model by analyzing the external text received from the external application.

Abstract: In an embodiment, an identifier of a storage location that is accessed by a program is received. While execution of the program is halted at a halted statement, a first source statement is determined that must have stored to the storage location. The program comprises the halted statement and the first source statement, and the halted statement is different than the first source statement. The first source statement is presented, in response to the determination. In an embodiment, while execution of the program is halted at the halted statement, a second source statement is determined that might have stored to the storage location, and the second source statement is presented.

Abstract: In a distributed system that includes a debug server and debug clients coupled for data communications through a data communications network, where the debug server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes: receiving, by the debug server from the debug clients asynchronously during a debug session of the debuggee, a plurality of application-level messages, receiving, from a requesting debug client, a request to notify other debug clients that the requesting debug client is presently modifying a value of a particular variable; routing, by the message router, the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including distributing to the other debug clients a notification of the modification the value of the particular variable; and returning, to the debug clients, client-specific debug results.