Abstract: A development system for developing enterprise software. The system consists of a data store maintaining information related to enterprise hardware components, including information on servers and applications operating on the servers. The system also includes an architectural component including a display operable for architecture of the enterprise software by selection via the display of one or more of the servers and applications operating on the servers. Also included in the development system is a development engine that can deploy a first integrated development environment for development of a first software component, and deploy a second integrated development environment for development of a second software component. The system also includes an interface component that allows information stored in a data store by the first integrated development environment to be accessible by the second integrated development environment.

Abstract: A system and method facilitating attributed debugging is provided that facilitates a developer of an object to determine what information a debugger displays. An expression evaluator is provided. The system can further include, optionally, a debuggee (e.g., process to be debugged). The debuggee includes attribute(s) which are employed by the debugger to facilitate debugging of the application—“attributed debugging.” This allows a developer of a type to declaratively indicate how information is to be displayed during debugging. Attributed debugging thus allows the manipulation of the view of data in the debugger by allowing the type author annotations with which they can control.

Abstract: A method for receiving, storing, and applying an update package to modify an original image stored within non-volatile flash memory devices. More specifically, the present design provides a download agent responsible for communicating with a server to transfer and store the update package; and an update agent responsible for verifying, decompressing and decoding the update package. The present design separates non-essential operating system (OS) components and applications from the core OS, stores non-essential OS components, applications, and download agent as a single image in a read-only file system. This image may be updated by applying an update package created by running a binary differencing engine on two pre-built file system images representing the current and new file systems to modify the stored image. Additionally, the present design applies an update package to the core OS, which includes the update agent.

Abstract: A linker profiler tool facilitates maintenance and management of object ordering between releases of firmware. By maintaining object ordering, code differences between firmware builds are reduced, which reduces the size of a package of update information used to update an electronic device from one version of firmware to another. Information used by an object code linker in a firmware build activity is processed to minimize changes in code object ordering between builds. The impact on the size of the update information caused by updates to firmware/software component in the build is thereby reduced to a minimum.

Abstract: Dynamically compiled computer program code containing virtual calls can reduce the options for optimization during compilation. A virtual call can affect sections of the program code that are compiled subsequent to the virtual call. Therefore, the state under which the effected sections are to be executed may not be known at the time of compilation thus complicating optimization of these sections. If assumptions are made about the state of an effected section, then this section can be optimized. In order to provide proper operation of the executing program code given the optimization, a check of the validity of the assumptions is performed prior to execution of the optimized section. If an assumption does not hold true then the original un-optimized section can be executed to reduce adverse program performance.

Abstract: Techniques for tracing the real-time operation of software for the purposes of testing, debugging, or performance analysis are disclosed. Diagnostic instrumentation for generating records containing details of software operation is incorporated in the software by inserting calls to diverse macros or inline functions. Each macro takes an argument specifying both a subsystem and a category of instrumentation within the subsystem. Based on the specified subsystem and category, the instrumentation can be included or excluded from the compiled object code and, if included, can be dynamically enabled at run-time. Disabled instrumentation does not result in a function call, but only a single, inline “if,” thereby reducing overhead. One macro accepts both software parameters and a custom format specifier describing how the parameters should be displayed. However, the parameters are not formatted during logging, nor is the format specifier included in the record. Instead, the formatting is performed when displayed.

Abstract: A connection is established between the source code and the business requirements of a software system. User specified keyword that reflect business requirements are expanded using an ontology and a thesaurus. The augmented list of user specified keywords are matched to the automatically annotated source code. The results of the match along with call graph of the source code are used to generate workflows that provide a mapping from the source code to business logic.

Abstract: A system and method is described for visually editing a stacked object in a design view canvas of an application development environment. Within the design view canvas, a badge control is rendered that is associated with the stacked object. A set of one or more navigation tools is contained within the badge control along with a set of one or more editing tools. When the user interacts with the navigation tools, presentation of the information contained by the stacked object is controlled. When the user interacts with the editing tools, the content and composition of the stacked object can be manipulated.

Abstract: A product design method includes accessing a defined product design structure. The product design structure includes a number of customer concerns, a number of physical properties associated with components of the product, and a number of relation models. Each customer concern is associated with at least one physical property via at least one mathematical relationship defined in at least one of the relation models. The method also includes receiving a value associated with one or more of the physical properties and calculating (using one or more of the relation models) the effect of the received value associated with the one or more physical properties on one or more of the customer concerns. Furthermore, the method includes displaying the calculated effect on the one or more customer concerns and receiving one or more adjustments of the value associated with one or more of the physical properties to create a desired effect on one or more of the customer concerns.

Abstract: Methods and apparatus, including computer systems and program products, for sharing classes and class loaders. One implementation provides a technique for performing a shared load procedure for a class, performing a post load procedure for the class, performing a shared link procedure for the class, performing a post link procedure for the class, and performing an initialization procedure for the class to reduce memory consumption and class loading time. Through performance of these procedures, a first portion of the class (which may include a class block and object) is loaded into a shared memory accessible by multiple runtime systems, and a second portion of the class (which may include a class static variable) as is stored in a local memory associated with a selected runtime system. A shared master copy of the second portion of the class is also stored in the shared memory.

Abstract: The techniques and mechanisms described herein are directed to a method for virtually catching an exception. A debugger receives a notification identifying information about an exception that occurred during execution of an application. The debugger then selectively chooses a location on a call stack where execution of the application resumes after the stack is unwound up to the selected location. The location being between a statement on the stack causing the exception and a handler on the stack. The handler being identified during a search phase for exception processing. The mechanism being operative for both handled exceptions and unhandled exceptions.

Abstract: A method of translating binary code instructions from a source format to a target format for processing by a target processor includes converting a source instruction into a source intermediate data structure having a plurality of members, mapping the members in the source intermediate data structure to corresponding members in a target intermediate data structure according to a template, and converting the target intermediate data structure into a target instruction.

Abstract: A method and system for determining code coverage of one or more software modules is disclosed. The disclosed method and system uses an enumeration module, a code coverage module and an analysis module. The enumeration module is used to identify portions of the code in the software module for which code coverage data is desired. The code coverage module collects code coverage data when the software module is loaded. The analysis module summarizes and reports results of the collected code coverage data.

Abstract: A method of optimizing the runtime performance of a program written in an interpreted programming language can include loading, within a virtual machine having a Just In Time (JIT) compiler, the program and a file specifying frequency of execution data for at least one component of the program. The program can be executed. The executing step can include reading the file specifying the frequency of execution data, seeding a counter of the virtual machine associated with the component(s) with a value derived from the frequency of execution data, and performing a JIT action upon the component(s) of the program according to the seeded counter of the virtual machine.

Abstract: A concept for providing a process for parsing at least one code object comprising determining when a page associated with the at least one code object has been previously processed; parsing the page when the page is determined not to have been previously processed; and evaluating a value for a compilation attribute for the page, is described.

Abstract: The present invention is directed to systems and methods that treat the monitoring of a software application as a separate and independent concern from the software application itself. The present invention utilizes aspect oriented programming to intercept, analyze, decompose the application states of a software application and then to link appropriate non-invasive constructs into the software application code to provide application state information to an autonomic manager through a plurality of sensors. The autonomic manager analyzes the application state information for compliance pre-defined parameters, and takes appropriate corrective action including modifying the software application states using a plurality of effectors. The sensors and effectors are linked as non-invasive constructs to the software application, and in aspect oriented programming constitute aspects.

Abstract: A method for tracing an instrumented program, including associating an instrumentation provider with a trace point to provide a probe in the instrumented program, selectively enabling the probe to obtain an enabled probe, wherein enabling the probe includes defining an action to perform when the enabled probe is fired, firing the enabled probe during execution of the instrumented program, and performing the action when the enabled probe is fired, wherein the action is performed by a tracing framework.

Abstract: A system and method for providing exceptional flow control in protected code through memory layers. Code is generated. The generated code includes a sequence of normal operations and is subject to protection against copying during execution of the generated code. The generated code is instantiated as a master process into a master layer in a memory space. The master process is cloned by instantiating a copy of the master process as a child layer in the memory space. Execution points within the generated code are identified. A copy of at least a portion of the generated code containing each execution point as an exception layer is instantiated in the memory space. The generated code in the exception layer is patched at each identified execution point with operations exceptional to the normal operations sequence and which are performed upon a triggering of each execution point during execution of the generated code.