Abstract: A system and method for developing, deploying and implementing computer applications for a power system has an open software framework for developing mobile applications. The mobile applications are developed by combining predefined modules having functionality to monitor a power system, change configuration settings within devices installed on the power system and allow utility personnel to quickly respond to events occurring on the power system.

Abstract: According to one embodiment, a code optimizer is configured to receive first code having a program loop implemented with scalar instructions to store values of a first array to a second array based on values of a third array and to generate second code representing the program loop using at least one vector instruction. The second code include a shuffle instruction to shuffle elements of the first array based on the third array using a shuffle table in a vector manner, a blend instruction to blend the shuffled elements of the first array using a blend table in a vector manner, and a store instruction to store the blended elements of the first array in the second array.

Abstract: Embodiments include systems and methods for reducing instruction cache miss penalties during application execution. Application code is profiled to determine “hot” code regions likely to experience instruction cache miss penalties. The application code can be linearized into a set of traces that include the hot code regions. Embodiments traverse the traces in reverse, keeping track of instruction scheduling information, to determine where an accumulated instruction latency covered by the code blocks exceeds an amount of latency that can be covered by prefetching. Each time the accumulated latency exceeds the amount of latency that can be covered by prefetching, a prefetch instruction can be scheduled in the application code. Some embodiments insert additional prefetches, merge prefetches, and/or adjust placement of prefetches to account for scenarios, such as loops, merging or forking branches, edge confidence values, etc.

Abstract: A method for upgrading software having steps (A) to (D) is disclosed. Step (A) may deny a first server access to read from and write to a database controlled by a second server while second software in the second server is being upgraded. The second software as upgraded may be incompatible with first software running in the first server. Step (B) may generate data in the first server in response to a current operation of the first software while the second software is being upgraded. Step (C) may update the database by transferring the data from the first server to the database through the second server after the upgrade of the second software has finished. The first server generally remains denied to read from the database. Step (D) may upgrade the first software to be compatible with the second software in response to finishing the current operation.

Abstract: A model-oriented programming method for computer-based software system development and management. The method includes (a) obtaining the program problem specifications, (b) building a model of the software system, (c) segmenting the model into model segments, wherein each of the model segments is assigned to a programmer, (d) writing a code for each of the model segments, wherein the code implements the assigned model segment, (e) running a model-driven dry-run and upon detection of a model error fixing the error and proceeding with step (c), (f) debugging the code by each of the programmers and upon detection of a model error fixing the error and proceeding with step (c), (g) integrating the code corresponding to each of the model segments into a computer-based software system, and upon detection of a model error fixing the error and proceeding with step (c), and (h) delivering the integrated computer-based software to the client.

Abstract: A processor-implemented method, system, and/or computer program product automates regression testing based on cyclomatic complexity of changed code. A base code change to a software program is identified as having a particular cyclomatic complexity. Multiple different software test routines are mapped to the base code change. A specific quantity of the different software test routines are then run to test the base code change, where the quantity of test routines that is run is based on the cyclomatic complexity of the base code change.

Abstract: A method, computer program product, and system is described. Software code text associated with a software code editor and including one or more preprocessor statements is identified. The software code text is translated into a preprocessor output using one or more preprocessors associated with the software code text. One or more transformations of the one or more preprocessor statements is identified based upon comparing the preprocessor output with the software code text. One or more locations in the software code text associated with the one or more transformations is identified based upon comparing the preprocessor output with the software code text. The software code text is parsed, based upon lexing the software code text to generate an integrated token stream model including a first token stream representing the software code text and one or more other token streams representing the one or more transformations of the software code text.

Abstract: In a method of binding a software item to a plain English name, a user input of a plain English control name is received into a test file. A user interface under test is automatically searched for a control corresponding to the plain English control name. The corresponding control in the software item under test is automatically bound to the plain English control name.

Abstract: According to an example implementation, a computer-readable storage medium, computer-implemented method and a system are provided to receive a first class, the first class indirectly implementing a first interface, wherein the first class extends a second class that directly implements the first interface, identify one or more directly implemented methods within the first class, determine a method signature for one or more of the directly implemented methods, estimate that the first class indirectly implements the first interface based on the method signatures for the one or more directly implemented methods, and instrument the first class based on the estimating that the first class indirectly implements the first interface.