Abstract: In an example embodiment, a container is downloaded, the container being an application natively executable by a first operating system of the user device, the container including: a container service including one or more libraries of functions designed by a container designer to natively operate on the first operating system; a browser; container metadata defining functions of the application, the functions compatible with the container service for the first operating system and also compatible with a container service for a second operating system; and a plug-in including one or more additional libraries of functions designed by an entity other than the container designer to perform additional native operations on the first operating system. Then, the container metadata can be executed using the browser, causing function calls to the container service and plug-in and thus controlling native functions of the user device.

Abstract: Concepts and technologies are described herein for a software builder. According to the concepts and technologies disclosed herein, a development platform can execute a software builder. The development system can receive input for creating a mobile application. In response to receiving the input, the development system can create build assets associated with the mobile application. The build assets can include components of the mobile application. The development system also can validate the build as sets, store the build assets at a data storage location, compile the assets, and output the mobile application.

Abstract: An object oriented application framework is provided in which base classes are decoupled from derived classes by using attributes. Relationships between derived classes and attributes can be generated, and derive classes can be statically or dynamically instantiated at run time. By decoupling the base class from derived classes using instances of such attributes, a developer does not modify computer program code defining the base class when adding customized extensions to that base class. The framework includes a class factory that uses instances of attributes associated with elements to derive, at run time, extension classes. The attributes can be specified at run time to specify or to alter the run time behavior of the application. This framework also allows the application to conditionally instantiate an element based on its attributes.

Abstract: To which method on each method call order pattern included in a series of application codes executed in response to a request a method included in an application code executed in response to a request corresponds is detected; a code is generated based on identification information corresponding to the detected method on the call order pattern; and the generated code is inserted to the application code.

Abstract: A process for creation of an equipment health monitoring (EHM) tool, including defining functional requirements for a proposed EHM tool in a structured hierarchical format. The functional requirements definition is used to generate an outline model for a plurality of functions of the proposed EHM tool according to a model template, wherein the outline model is captured as one or more graphical representations. Each graphical representation includes at least one component representative of a defined EHM functional requirement. Source code for the proposed EHM tool is automatically generated based upon the graphically represented model and then compiled to create a deployable EHM tool from the source code by applying a compilation strategy dependent on an intended mode of operation for said EHM tool. An EHM generation tool and associated data carrier are also recited.

Abstract: A status management device is presented, the device including multiple first application units for monitoring status information indicating a status of a management target, multiple second application units for outputting first acquisition request information of the status information with identification information of the management target, a search unit for outputting a storage location corresponding to the identification information when the first acquisition request information is received from the second application unit, a request unit for outputting second acquisition request information of the status information to the first application unit corresponding to the outputted storage location, and a transmission unit for outputting the status information supplied from the first application unit in response to the second acquisition request information to the second application unit which corresponds to a request source of the first acquisition request information.

Abstract: An approach for consolidating and reusing portal information within different web applications. The approach includes a method that includes retrieving, by at least one computing device, code from an application. The method includes deconstructing, by the at least one computing device, the code into code fragments. The method includes validating, by the at least one computing device, each of the code fragments. The method includes matching, by the at least one computing device, each of the code fragments with server-side components. The method includes generating, by the at least one computing device, a portlet based on the matching.

Abstract: Described herein are techniques to provide read and write barriers for flexible and efficient garbage collection. A memory heap is split into pages. Each page is aligned to an address that is a multiple of a particular power of two. When generating read and write operations, code is generated to execute the write barrier or the read barrier. At this point, the page alignment for each pointer is known; for example, if the page alignment is the same for all pointers in the system. With this page structure, it is possible to find the page start by masking the address of any heap allocated object on the page with a mask based on the page alignment (bitwise-and operation). A plurality of flags are established on a page. This Abstract is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims.

Abstract: Coupling architectural and implementation/behavioral models of a computer-based system by creating a bridge element, defining a port of the bridge element, associating the port of the bridge element with a port of an implementable element of an architectural model of a computer-based system and a port of an implementation element of an implementation/behavioral model of the computer-based system, mapping an interface member of the implementation element port to an interface member of the implementable element port, generating, from a template, skeleton source code applicable for the mapped interface member, generating a usage description element for the architectural model corresponding to the mapped interface member, generating an architectural description document from the architectural model, generating implementation code from the implementation/behavioral model and the generated skeleton source code, and generating a declaration file for an operating system service for use by the implementation code.

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: A computer-implemented business process deployment system and method are disclosed. The system includes memory which stores a design tool which receives a business process description and generates a deployment package composite based thereon. The business process description includes a set of business process activities for a business process, each of the business process activities in the set depending on abstract services for implementing the business process activity. An abstract bindings repository stores mappings between the abstract services and corresponding real services employed by an associated real service employing system. The deployment package composite is configured to bind the abstract service dependencies to the real services in the abstract bindings repository to generate a deployable business process composite that is deployable in the associated real service employing system. A processor implements the design tool.

Abstract: A method and system for processing instruction information. Each instruction information character string of a sequence of instruction information character strings are sequentially extracted and processed. Each instruction information character string pertains to an associated target object wrapped in a target object storage unit by an associated operation target model. It is independently ascertained for each instruction information character string whether to generate a code line for each instruction information character string, by: determining whether a requirement is satisfied and generating the code line and storing the code line in a code buffer if the requirement has been determined to be satisfied and not generating the code line if the requirement has been determined to not be satisfied. The requirement relates to whether the instruction information character string being processed comprises a naming instruction or a generation instruction.

Abstract: A system and method for encapsulating a target application are described herein. In particular, an analysis of the target application can be performed to determine one or more characteristics of the target application. Based on the analysis of the target application, a blueprint of the target application can be generated. Based on the blueprint, an encapsulation application can be constructed for the target application. In addition, the target application can be encapsulated with the encapsulation application to create an encapsulated target application to enable adaptive loading of the target application.

Abstract: A system implementing a method for generating code for execution based on a SIMT model with parallel units of threads is provided. The system identifies a loop within a program that includes vector processing. The system generates instructions for a thread that include an instruction to set a predicate based on whether the thread of a parallel unit corresponds to a vector element. The system also generates instructions to perform the vector processing via scalar operations predicated on the predicate. As a result, the system generates instructions to perform the vector processing but to avoid branch divergence within the parallel unit of threads that would be needed to check whether a thread corresponds to a vector element.

Abstract: Application requirements may be determined for executing an application using a sensor network, the sensor network including a plurality of devices. Hardware constraints associated with the devices may be determined, and an operating system may be generated, based on the application requirements and the hardware constraints. In this way, an operating system may be generated that is specific to, and optimized for, the the particular application and hardware resources.

Abstract: A machine vision system program editing environment including synchronized selection and/or identification of related features in a plurality of different user interface windows is provided. In particular, one of the windows is an editing window where a part program representation is displayed for editing by a user. In one embodiment, a user may select data or another feature of interest in a window that is not the editing window (e.g., a results window, or graphical workpiece inspection feature display window) and the associated part program instruction representation is automatically highlighted and/or selected in the editing window. Conversely, a part program instruction representation may be selected by a user in the editing window and the associated results or feature in another window is automatically highlighted and/or selected. User interface navigation, rapid program quality assessment, and overall part program creation and editing efficiency are significantly enhanced in such an editing environment.

Abstract: A system is operable to provide one or more test environments for executing and analyzing test routine. The system includes one or more user interfaces coupled via a communication network to a server arrangement for hosting a plurality of emulations of wireless communication devices or terminals. The server arrangement is operable to receive one or more software applications for execution upon the wireless communication devices or terminals, and one or more test routines for use in testing the wireless communication devices or terminals. Moreover, the server arrangement is operable to execute one or more the software applications and apply the one or more test routines thereto. Furthermore, the server arrangement is operable to monitor operation of the wireless communication devices or terminals and to provide corresponding test results to the one or more user interfaces.

Abstract: A device and method automatically generate a program for buffering differences based on characteristics of a component. A buffer program for buffering differences of the way to use a component during different software environments is automatically generated. The device includes a controller for executing automatic generation of the buffer program, a memory including control information and a processing program, an input device for inputting the processing content of the component, and an output device for outputting the automatically generated buffer program. The memory records a plurality of forms for buffering the component as the control information and the controller extracts characteristic information based on the processing content of the component and records the extracted characteristic information as control information in the memory, selects a specified form based on the characteristic information, and generates the buffer program based on the selected form and the characteristic information.

Abstract: A method of transmitting data is disclosed. At least one system block of a system-on-chip (SoC) is modeled at an untimed functional level in first and second untimed functional models. First and second transaction level (TL) models of the at least one system block system block are modeled at a transaction level (TL) using the first and second untimed functional models, respectively. First and second cycle accurate (CA) models are modeled at a cycle accurate (CA) level using the first and second TL models, respectively. Data is transmitted from the first untimed functional model to the first CA model, from the first CA model to the second CA model via a CA bus, and from the second CA model to the second untimed functional model.

Abstract: An aeronautical software application development workbench handling the production of a graphical human-machine interface on one or more display equipment systems comprises computer means processing software tools for creating, simulating or integrating graphical functions or “widgets” and logic functions for modifying the content of the graphical functions according to incoming events on the display equipment system or systems, said widgets being described in a file called “Definition File”. The workbench includes a single graphical editor for designing the user application, the technical characteristic of which is to produce a structured language which describes each widget contained in the definition file and which associates consumed variables called “input plugs” with the modifiable attributes of said widget and produced variables called “output plugs” with the notifications of the events produced by said widget.

Abstract: Systems and methods for developing and delivering platform-adaptive web and native application content are disclosed. A hierarchy of templates is provided in which each template includes content compatible with a device that has various associated characteristics, such as particular hardware and software configurations. At least one of the templates has an inheritance relationship with one or more other templates in the hierarchy. A request for content is received from a requesting device. The request includes a device identifier, such as a user agent string, indicative of one or more characteristics associated with the requesting device. One or more of the templates are then selected based on the device identifier and are used to generate content compatible with the requesting device.

Abstract: A system for generating a diverse program can include a diversification unit configured to generate the diverse program that can include a given set of instructions implemented as machine code and/or assembly language instructions based on a compiled program. The compiled program can include another set of instructions implemented as machine code and/or assembly language instructions.

Abstract: A method and apparatus for using a microcontainer as a Plain-Old-Java-Object (POJO) based kernel in an application server. In one embodiment, the method includes dynamically construct deployed objects of a deployment from aspects. The method further includes providing a runtime infrastructure by dynamically constructing kernel objects of an application server from the aspects to execute the deployed objects.

Abstract: Various embodiments described or referenced herein are directed to different devices, methods, systems, and computer program products for testing a user interface component. A client-side operation for rendering the user interface component may be performed. The rendered user interface component may be stored as a user interface component test image simulating a visual presentation of the user interface component at a client machine. A user interface component expected image may be retrieved from a storage medium accessible to the server. The user interface component expected image may represent an expected visual presentation of the rendered user interface component. A determination may be made as to whether the user interface component test image matches the user interface component expected image. When the user interface component test image does not match the user interface component expected image, an indication of an error condition may be provided.

Abstract: A method for establishing a support environment for a program may include identifying one or more support environment features depended upon by the program to run on one or more nodes, selecting one or more support software components indicated to provide the features, loading the selected support components on the one or more nodes, configuring the selected support components based on the program, and causing the program and the selected support components to be executed on one or more nodes.

Abstract: Systems and methods which provide platform sensitive application characteristics with respect to multi-platform applications are shown. As application aspects are developed in the application, embodiments include platform sensitivity characteristics for the application aspects in the application to provide for adaptation of application characteristics for multiple platforms. Embodiments provide an application runtime environment which, although independently defining its own user interface rendering attributes, operates to adjust application characteristics in accordance with a host platform. As application aspects of a multi-platform application are to be executed, if there are relevant cross platform differences, application aspect characteristics are adjusted so as to be appropriate to the host platform. The appropriately adjusted aspects are executed to thereby provide platform sensitive application characteristics with respect to the multi-platform application.

Abstract: Systems and methods which provide platform sensitive application characteristics with respect to multi-platform applications are shown. As application aspects are developed in the application, embodiments include platform sensitivity characteristics for the application aspects in the application to provide for adaptation of application characteristics for multiple platforms. Embodiments provide an application runtime environment which, although independently defining its own user interface rendering attributes, operates to adjust application characteristics in accordance with a host platform. As application aspects of a multi-platform application are to be executed, if there are relevant cross platform differences, application aspect characteristics are adjusted so as to be appropriate to the host platform. The appropriately adjusted aspects are executed to thereby provide platform sensitive application characteristics with respect to the multi-platform application.

Abstract: A code ID range table holding code ID ranges for each code of a same code type and a next code ID table holding next code IDs are created. Code ID ranges of code types of codes configuring a search code string are read out from the code ID range table for the search target code string, and the stored next code ID corresponding to a code ID included in the code ID range of the code type of the head code in the search code string is read out from the next code ID table while the stored next code IDs corresponding to the next codes are successively read out from the next code ID table, and the next code ID read out from the next code ID table is verified whether it is included in the code ID range read out from the code ID range table.

Abstract: Methods and systems for a disabled user compliant video player for an end-to-end streaming web video solution affording accessibility for disabled users, including blind users and those with partial or poor vision, colorblind users, deaf users and those limited to only keyboard/voice input. Another embodiment of the present invention is directed to systems and methods for real-time creation and modification of specialized media players, to be used as stand-alone applications or as embedded data display applications.

Abstract: A dynamically evolving cognitive architecture system based on contributions from third-party developers is described. A system receives a span of natural language annotated with an object from a first third-party developer. The system forms an intent based on a user input, which includes a natural language span which corresponds to an action object, a first concept object, and/or a second concept object. The action object, the first concept object, and/or the second concept object is provided by a second third-party developer. The annotating object is the action object, the first concept object, or the second concept object. Forming the intent enables executing the action object to transform the first concept object into the second concept object based on the annotated span of natural language, and also enables outputting a value associated with the second concept object associated with a goal of the intent.

Abstract: Systems and methods for processing software application metadata associated with a software application are provided. A representative method includes the step of collecting software application metadata associated with a software application. The software application metadata includes a first set of information related at least one of the following: screens, paths, and layers associated with the software application. The method further includes the step of storing the software application metadata in a data repository.

Abstract: A file system which ensures that some of the (desired) files (“linear files”) are stored in corresponding exclusive blocks (i.e., a block that stores data corresponding to one file only). Due to such a feature, rewriting of data corresponding to other files would not cause data corresponding to linear files to be relocated/rewritten. Such a feature may provide reliable and steady retrieval of data of the corresponding file from a flash memory organized as sectors. According to another aspect, some of the files (“non-linear files”) are stored in non-exclusive blocks (i.e., multiple files can share the same block or the same file can span multiple blocks without contiguity).

Abstract: The present disclosure involves computer-implemented methods, software, and systems for managing a transition between business process models. A computer-implemented method includes in parallel with a first business process model, instantiating, using at least one hardware processor, a second business process model, instantiating a temporary exit process step of a set of temporary exit process steps associated with the first business process model and a temporary entry process step of a set of temporary entry process steps associated with the second business process model, coupling an exit transition rule of a set of exit transition rules associated with the first business process model to the first business process model, and activating the exit transition rule after activating the second business process model.

Abstract: A computer system receives user input indicating uniform resource identifiers (URIs) for a RESTful web service. The computer system identifies a programming language for a RESTful web service software development kit (SDK) client and creates methods for the URIs using programming code format of the identified programming language. The computer system creates the RESTful web service SDK client using the methods.

Abstract: An approach is provided in which a request is received from a software module to retrieve a value stored in a pre-defined location. Prior to retrieving the value, an override tank is checked for a corresponding override value. When the override tank includes an override value, the override value in the override tank is provided to the software module. When the override tank fails to include a corresponding override value, an actual value is retrieved from a pre-defined storage location and provided to the software module. In one embodiment, the override value is an override system attribute value. In another embodiment, the override value is an override function return value.

Abstract: A system for tracing operations during application execution and executing the traced operations on a second processing unit. The tracing involves identifying attempts to execute software that performs particular functions that would benefit from execution on a particular piece of non-compatible hardware and, rather than executing the code, recording the requests and the data inputs to each of the requests. At a point during execution of the software system such as, for example, when either a memory threshold has been exceeded for recording the requested code and inputs, or results are needed for the requested code, the corresponding code executable on the non-compatible hardware is identified and executed. Thereafter, the results from the execution on the non-compatible hardware are received and processing continues.

Abstract: In an embodiment, a modeling component generated in a first modeling environment can be implemented in a second modeling environment. The modeling component is executed in the first modeling environment. A first behavior of the modeling component in the first modeling environment is obtained based on the executing. The modeling component is then executed in the second modeling environment. A second behavior of the modeling component in the second modeling environment is obtained based on the executing the modeling component in the second modeling environment. The first behavior is compared to the second behavior. Based on the comparing, it is verified that the second behavior of the modeling component complies with one or more modeling requirements of the second modeling environment. The second behavior of the modeling component may be implemented in the second modeling environment.

Abstract: TSQL debug breakpoint interoperability across heterogeneous project systems within an IDE can be provided. A user can set a breakpoint in the user's SQL source code and the breakpoint can be triggered by the code within another project. Breakpoints can be set and triggered within SQL source code tiles that reside in one or more SQL Database projects. Binding of the application project being debugged with one or more SQL Database projects that reside within the IDE session can be automated, SQL artifacts not found in any of the SQL Database projects can be debugged.

Abstract: In one embodiment, the invention comprises partial fault tolerant stream processing applications. One embodiment of a method for implementing partial fault tolerance in a stream processing application comprising a plurality of stream operators includes: defining a quality score function that expresses how well the application is performing quantitatively, injecting a fault into at least one of the plurality of operators, assessing an impact of the fault on the quality score function, and selecting at least one partial fault-tolerant technique for implementation in the application based on the quantitative metric-driven assessment.

Abstract: An approach is provided in which a request is received from a software module to retrieve a value stored in a pre-defined location. Prior to retrieving the value, an override tank is checked for a corresponding override value. When the override tank includes an override value, the override value in the override tank is provided to the software module. When the override tank fails to include a corresponding override value, an actual value is retrieved from a pre-defined storage location and provided to the software module. In one embodiment, the override value is an override system attribute value. In another embodiment, the override value is an override function return value.

Abstract: A system and method for accessing closure variables from a lambda expression in certain program configurations, in which the closure variable is accessed while the closure function is active and the closure variable is within an active runtime frame stack corresponding to an instance of the closure function. In response to entering the closure function, a pointer to each closure variable is stored in a stack pointer table. Each reference to each closure variable from the lambda expression is handled by using the closure variable pointer to locate the closure variable on the runtime stack. Program code may be instrumented to insert invocations to helper functions at locations upon entering the closure function and at each reference to each closure variable from the lambda expression.

Abstract: Systems and methods may generate applications for operating platforms. A data source for an application definition may be created, and an object may be mapped to the data source. An application definition may be generated from the data source and object. An operating platform for application publication may be selected from among a plurality of platforms. An application may be generated for the selected operating platform.

Abstract: A parallelization assistant tool system to assist in parallelization of a computer program is disclosed. The system directs the execution of instrumented code of the computer program to collect performance statistics information relating to execution of loops within the computer program. The system provides a user interface for presenting to a programmer the performance statistics information collected for a loop within the computer program so that the programmer can prioritize efforts to parallelize the computer program. The system generates inlined source code of a loop by aggressively inlining functions substantially without regard to compilation performance, execution performance, or both. The system analyzes the inlined source code to determine the data-sharing attributes of the variables of the loop. The system may generate compiler directives to specify the data-sharing attributes of the variables.

Abstract: A method, system, and computer program product for computer-aided software application development. A synthesizer commences upon receiving a mobile device identifier and additional information such as an application identifier, an object model, and/or a form identifier, then analyzing the additional information to determine what form(s) to implement on the mobile device. Further synthesis processing includes analyzing the forms to determine a set of functions to implement on the identified mobile device. Using the determined set of functions, native application code modules are retrieved from a repository. The retrieved native application code modules correspond to the set of functions. The code modules are integrated together to generate a native mobile application, which can be deployed to a mobile device. Messages from the mobile device are intercepted so as to emulate form processing of a back-end application. Any back-end applications that use the form can be accessed by the native mobile application.

Abstract: A method, system, and article of manufacture for solving ordinary differential equations described in a graphical model with nodes as blocks and dependencies as links using the processing of a computer with a plurality of processors. The method includes: generating segments of block with or without duplication for each block with an internal state and for each block without any output by traversing the graphical model from each block with an internal state to each block without any output; merging the segment to reduce duplication; compiling and converting each segment from the merged results in an executable code; and individually allocating the executable code for each segment to a plurality of processors for parallel execution.

Abstract: A system and method for producing a massive number of diverse program instances so as to deter differential attacks, collusion, and similar hostile actions. Code portions are shown to be defined in various manners, instantiated, and aggregated. The system and method establishes a very large number of program instances that may be deployed. Furthermore, testing is accomplished over a minimal set of instances to provide for high test coverage and high confidence over the fully deployed in stance set without incurring a high penalty.

Abstract: A system and method automatically generates an object-oriented, textual program from a graphical model, and verifies the performance of the textual program as compared to the graphical model. The graphical model may have a plurality of interconnected blocks, and each block may have a plurality of parameters. One or more of the blocks are mapped to a system object, and the block's parameters are mapped to properties of the system object. An object-oriented, executable textual string is generated automatically for the block. The generated string includes at least one command to: instantiate a system object having functionality that matches the block; set one or more properties of the system object based on the block's parameters; and run the instantiated object.

Abstract: An illustrative embodiment of a computer-implemented process for target application creation receives a representation of a logical topology diagram for an application architecture to form a source input, locates part type information in a part type dictionary using the source input, locates application parts in an application parts repository for each located part type and composes a subset of identified parts. The computer-implemented process further determines whether integration dependencies are met and responsive to a determination that integration dependencies are met, consolidates parts into an application structure, determines whether to exclude parts and responsive to a determination to not exclude parts, builds a target application.

Abstract: Provided is an apparatus and method for generating code overlay capable of minimizing the number of memory copies. A static temporal relationship graph (STRG) is generated in which each of functions of a program corresponds to a node of the STRG and a conflict miss value corresponds to an edge of the STRG. The conflict miss value is the maximum number of possible conflict misses between functions. Overlay is generated by selecting at least one function from the STRG, calculating an allocation cost for each region of a memory to be given when the at least one selected function is allocated, and allocating the at least one selected function to a region that has the smallest allocation cost.

Abstract: A program optimizer includes an energy tracking system, an energy monitoring system, and a code generation control system. The energy tracking system measures a pulse signal of a DC-DC converter that provides energy to a processor. The energy monitoring system determines, based on values received from the energy tracking system, attributes of operation of the processor. The code generation control system determines whether the values indicate that the execution of a first version of a program uses an amount of energy that is outside a predefined energy range, and to: 1) identify a parameter of an instruction generator that if changed will cause a second version of the program, when to use an amount of energy that is within the predefined energy range; 2) change a value of the identified first parameter; and 3) produce a second version of the program based on the changed value of the first parameter.