Abstract: A system for managing a software asset including asset files for inclusion in a library includes: (a) a receiving manager configured for receiving the asset, verifying source of the asset and reading an installer package into the asset to establish a received asset; (b) a build manager coupled with the receiving manager and configured for creating an application wrapper file for the received asset; the build manager creating folders in a folder structure and distributing the asset files among the folders to establish a distributed folder file; the build manager using the distributed folder file to create the application wrapper file; and (c) a peer review manager coupled with the build manager and effecting a peer review process with the application wrapper file to establish a reviewed application wrapper file; the peer review manager unit cooperating with the build manager to present the reviewed application wrapper file to the library.

Abstract: Certain exemplary embodiments comprise a system. The system can comprise a user interface renderer, which can be adapted to render a plurality of distinct user interfaces. Each user interface from the plurality of distinct user interfaces can be adapted to configure a corresponding software application from a plurality of software applications associated with operating a programmable logic controller (PLC).

Abstract: A method for assembling parametric information processing applications, includes: receiving a composition request; composing a processing graph for the request, wherein the processing graph represents an application that includes at least one component; identifying a deployment parameter of the component and requesting a value of the parameter; receiving the parameter value; applying the parameter value to the application; and deploying the application with the parameter value in an execution environment.

Abstract: Optimized storage of function variables in compiled code is disclosed. It is determined that a variable of a first function is required to be available for use by a second function subsequent to return of the first function. Machine code is generated to escape the variable from a storage location in a stack memory to a storage location in a heap memory, prior to the variable being removed from the stack memory, in connection with return of the first function.

Abstract: The present application is directed towards systems and methods for applying one or more rules that transform objects of an application from a previous instance of the application. Customized functions, objects, databases, and code of the instance of the application may be analyzed by an application transformation tool to identify one or more objects that have been modified. The modified objects may be further analyzed to detect if they are permissibly alterable. The application transformation tool may determine whether each of the permissibly alterable objects reference a standard interface of the application. The application transformation tool may apply one or more rules that transform objects to those permissibly alterable objects that do not reference the standard interface of the application.

Abstract: A method for configuring and executing card content management (CCM) operations in a declarative manner includes composing a CCM operation declaration, wherein each CCM operation includes one or more CCM scripts and storing the CCM operation declaration in memory. When provisioning is needed, applicable scripts for the CCM operation declaration are fetched from the memory. An execution context needed for each script in the CCM operation declaration is prepared. The scripts are executed in an order specified in the CCM operation declaration.

Abstract: In various embodiments, a data integration system is disclosed which enables users to create a logical design which is platform and technology independent. The user can create a logical design that defines, at a high level, how a user wants data to flow between sources and targets. The tool can analyze the logical design, in view of the user's infrastructure, and create a physical design. The logical design can include a plurality of components corresponding to each source and target in the design, as well as operations such as joins or filters, and access points. Each component when transferred to the physical design generates code to perform operations on the data. Depending on the underlying technology (e.g., SQL Server, Oracle, Hadoop, etc.) and the language used (SQL, pig, etc.) the code generated by each component may be different.

Abstract: Input may be received indicating selection of multiple modules from a plurality of predefined configurable computation modules and to configure the selected modules. Configuring the selected modules may include defining one or more module inputs to each selected module and may also include defining one or more connections between modules of the selected multiple modules. The selected modules may be assembled based on the respective define one or more module inputs to each selected module and the defined one or more connections between modules. The assembled selected module may enable analysis to be performed on data received at the respective one or more module inputs.

Abstract: Processing a dataflow program by a program development tool includes analyzing an actor defined by the dataflow program to identify original sequences of actions that can be reformulated to achieve greater execution parallelism while maintaining the same functionality as the original sequences. A processed dataflow program is produced comprising processed dataflow program instructions and decision point program instructions. The processed dataflow program instructions comprise alternative sequences of reformulated actions that achieve greater execution parallelism while maintaining the same functionality as the identified one or more original sequences. The decision point program instructions direct processing equipment to select and execute one or more of the alternative sequences of reformulated actions, wherein selection is based on state and token information in existence at the time of selection.

Abstract: A system and method provided as a Web service for on-demand generation of libraries, as well as working samples, for a specified API, target programming language and target platform. The system is accessed through an interface and includes a Web application, a data store, and a compile server. The Web application is configured to receive a request for code generation from the user interface, to retrieve a description of an API, determine if code artifacts have been previously generated for the API description, and generating a source library in a programming language and target platform of choice based on the API description. The data store stores generated code artifacts, and stores the generated source library for the API description. The compile server is configured to generate compiled libraries and documentation, and store compiled libraries and documentation in the data store.

Abstract: The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system obtains a type interval for a generic type parameter of an implementation of an overloaded function. Next, the system selects an inference direction for the generic type parameter based on a variance of the generic type parameter, wherein the inference direction is an upward inference direction or a downward inference direction. Finally, the system uses the type interval and the inference direction to perform type inference on the generic type parameter.

Abstract: The present disclosure describes methods, systems, and computer program products for providing entity-based, cross-application navigation according to an implementation. One computer-implemented method includes receiving a request for data and callable entities associated with a provided entity context, transmitting the data and callable entities, receiving request for bootstrap code associated with a target application, generating bootstrap code containing an application environment runtime detection library and application environment navigation data, and transmitting the bootstrap code.

Abstract: A web browsing method and apparatus for enhancing a user's convenience in web browsing is provided in a system that uses a multi-core processor. The web browsing method and apparatus is applicable in a system, such as a smart phone that has a low computing power or that has a storage device like a flash memory operating in a rapid manner. Optimized machine codes are stored in files and incremental optimization is achieved, so the JAVASCRIPT® program of the web application has a small compilation overhead and achieves fast execution.

Abstract: An aspect of the present invention generates test cases for functional testing of a software application. In one embodiment, rules specifying corresponding patterns in a natural language and corresponding templates are maintained. Each pattern contains corresponding variables and words of the natural language together in an ordered sequence. On receiving a design document containing statements in the natural language, a first statement is determined to match a first pattern specified in a first rule. A match is deemed to exist only if the words in the first pattern exist in the first statement in the same corresponding positions of the ordered sequence, and if the first statement also contains values for each of the variables specified in the first pattern. A set of test cases is generated based on a first template specified in the first rule and the values for each of the variables.

Abstract: Systems and methods are provided for automated generation of a customized software product. A system includes a computer-readable medium encoded with a project parameters data structure, where the project parameters data structure includes a plurality of project requirement records, and a project prototype. One or more data processors are configured to process a plurality of initial characteristics for the customized software product, populate the project parameters data structure at least based on the initial characteristics, and generate the project prototype based on the project parameters data structure. The one or more data processors are further configured to output a requirements matrix data structure at least based on the project parameters data structure and the project prototype and to generate the customized software product at least based on the requirements matrix data structure and the project prototype.

Abstract: Disclosed here are methods, systems, paradigms and structures for optimizing intermediate representation (IR) of a script code for fast path execution. A fast path is typically a path that handles most commonly occurring tasks more efficiently than less commonly occurring ones which are handled by slow paths. The less commonly occurring tasks may include uncommon cases, error handling, and other anomalies. The IR includes checkpoints which evaluate to two possible values resulting in either a fast path or slow path execution. The IR is optimized for fast path execution by regenerating a checkpoint as a labeled checkpoint. The code in the portion of the IR following the checkpoint is optimized assuming the checkpoint evaluates to a value resulting in fast path. The code for handling situations where the checkpoint evaluates to a value resulting in slow path is transferred to a portion of the IR identified by the label.

Abstract: An image processing apparatus includes plural module creating units, plural wrapper creating units, an extracting unit, a calling unit, and an argument processing unit. The module creating units create processing modules that are obtained by instantiating different types of image processing classes by using functions. The wrapper creating units create wrappers that call the module creating units and that pass arguments specified in a pointer form to the module creating units. The extracting unit extracts, from image processing information, class names of the image processing classes corresponding to the individual processing modules and the arguments unique to the image processing classes. The calling unit converts the extracted class names and calls the wrapper creating units to which the converted class names are given. The argument processing unit stores the extracted arguments in an array, specifies an initial address of the array, and passes the initial address to the created wrappers.

Abstract: A method of providing multi-instantiable state templates to a statechart environment is discussed. The method includes the step of providing a graphical definition of an independent state machine object belonging to a statechart. The method further includes the step of instantiating a first instance and a second instance of the independent state machine object in the statechart. The method additionally includes the steps of starting execution of the first instance of the independent state machine object and then stopping execution of the first instance of the state machine object. Additionally, the method includes the step of starting the execution of the second instance of the independent state machine object in the state diagram.

Abstract: A computer-readable recording medium stores therein an IP model that combines source code of IPs that include an interface representing input/output of data; a register storing the data; a behavior executing processing based on the data; and a state performing wait processing according to time information from the interface and a connection code indicative of a connecting relation between the IPs.

Abstract: According to some embodiments, Application Programming Interface (API) source code, including command design patterns, is determined to be executed as a runtime scenario. Class may then be automatically generated as linkable building blocks in accordance with the API source code and command design patterns. For example, API command classes and associated methods may be dynamically read using reflection, and a building block class associated with each API command class may be generated. Runtime readable embedded metadata may be planted in the building block classes, at least some of the metadata being provided by the reflection. According to some embodiments, a logical sequence of the building blocks classes may be linked in accordance with the runtime scenario.

Abstract: A method, device and computer-readable storage medium for setting up runtime environment for an application are provided in the present disclosure. The method includes the following steps: determining whether the application is installed; when the application is determined being installed, creating a process of the application according to user's instruction; and providing an application platform interface for developing the application.

Abstract: A method for generating code in a predefined programming language based on an optimization problem is provided. The method includes reading a model of the optimization problem, and identifying references to external data sources in the model. The external data sources are external to the model. The method also includes generating the code. The code includes a program representation of the model. The code includes read and/or write accesses to the external data sources. A corresponding code generator and a software development environment are also provided.

Abstract: A method, system and computer program product for efficiently developing software and supporting creation of source code so as to develop software that meets the requirements. A plurality of test cases defining a plurality of respective tests to be executed to check the conformity of the software to the requirements are used. In a test execution step, one or more specific test cases selected from the plurality of test cases are executed or the specific test cases are caused to be executed. Furthermore, a test result of a test case executed or caused to be executed in the test case execution step is added to the source code.

Abstract: A method for efficiently developing software and supporting creation of source code so as to develop software that meets the requirements. A plurality of test cases defining a plurality of respective tests to be executed to check the conformity of the software to the requirements are used. In a test execution step, one or more specific test cases selected from the plurality of test cases are executed or the specific test cases are caused to be executed. Furthermore, a test result of a test case executed or caused to be executed in the test case execution step is added to the source code.

Abstract: A platform for device-independent business application development, based on XML-based type instructions and associated parameters, is described. The platform supports the hierarchical mapping of business needs onto business processes, action steps and OS and device-independent application descriptions to be interpreted, build, and executed on client devices. Upon receipt of the application description by a client device, the latter being configured to read and interpret the XML-based instructions and parameters of the application description, it creates a local application. The operating system selection, user interface, driver, hardware and firmware specific functionalities and control are taken care of by the client device.

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: A method and system for enabling multi-tenancy for software as a service application is provided. The method includes defining a plurality of policy configuration files for each tenant of the SaaS application. The method further includes identifying a tenant and tenant-context for the SaaS application. Thereafter, the method includes identifying one or more policy configuration files and then applying one or more variations to one or more variation points to provide the SaaS application to the user.

Abstract: A Model Transformation Authoring Framework (MTAF) method and apparatus for authoring and providing model-to-model transformations from one domain to another domain is disclosed. Given a domain and a target domain, at least the given domain having a respective structured hierarchy, the invention system enables a user to specify a declarative mapping (transformation declarative) between a domain specific language modeling the given domain and a modeling language modeling the target domain. The declarative mapping models how the domain specific language modeling the given domain relates to the modeling language of the target domain. The system generates a transformation code implementation of a transformation from the given domain to the target domain. The MTAF provides to the user design decisions with respect to Specification, Transformation Rules, Rule Organization, Rule Application Control, Source-Target Relationship, Incrementality, and Directionality and Tracing.

Abstract: In an embodiment, a model is sliced into a plurality of slices. A slice in the plurality of slices is selected. A portion of code, that corresponds to the selected slice, is identified from code generated from the model. The identified code is verified to be equivalent to the selected slice. Equivalence may include equivalent functionality, equivalent data types, equivalent performance, and/or other forms of equivalence between the selected slice and the identified generated code.

Abstract: A method, system and computer program product for decoupling components of a software system at load/compile time to accelerate application startup times. In particular, a software components partitioning (SCP) utility pre-defines a number of (implementation) classes to initiate and facilitate the decoupling process. The SCP utility allows the method names and argument lists to be recorded from a remote interface into a local interface which emulates the remote interface. The local interface is augmented with an annotation to define the remote interface. Additionally, a pre-defined keyword is appended to the name of the local interface to enable the creation of a (pre-defined) classname. Furthermore, when the classname is loaded, an implementation (via a Java implementation class, for example) for the remote class is loaded, and the implementation is associated with a dynamic proxy that implements both the local and remote interfaces, on demand.

Abstract: A method of defining data objects for use with an executable block diagram modeling and code generation system including providing pre-defined data object classes, each of the pre-defined data classes having default attributes, extending the pre-defined data object classes with subclasses, each of the subclasses having user-defined attributes and generating data objects, which are instances of the pre-defined classes and the subclasses.

Abstract: Certain example embodiments described relate to the generation of variables for data flow chains that are associated with control flow models. Certain example embodiments relate to the creation of a diagram (e.g., an automation diagram) that encapsulates the flow of data in a process model (e.g., EPC). In certain example embodiments, the generation of variables provides for linking executable processes via the automation diagram so that the data flow may be integrated into the EPC model. An EPC model may be transformed into a BPMN model. Optionally, the transformations may occur in reverse so that an automation diagram is created from a modified EPC model.

Abstract: A system and method for declaring variables during coding of a software program. The method includes, for each variable type, defining a unique string representing a variable declaration instruction and adapting a coding module wherein, generating code for the corresponding variable declaration statement for a new variable having the new variable name and the specified variable type, tracking the variable declaration instructions for each new variable name, and presenting a warning if a programmer attempts to use one of the previously used variable names to declare a new variable name of another data type. The method further includes defining a reserved variable declaration area in the software program and placing any code generated by the coding module for the variable declaration statement into the reserved variable declaration area. Each unique string representing a variable declaration instruction may be, for example, a prefix or suffix.

Abstract: A computer implemented method for providing code list extensibility includes providing a first code data type representation. The first code data type representation corresponding to a first code data type and having a first code value representation for at least one code value. The at least one code value associated with a corresponding code value issuing entity. The method may also include providing a second code data type representation. The second code data type representation corresponding to the first code data type and having a second code value representation for the at least one code value. The second code value representation including a unique identifier associated with the code value issuing entity. The method also may include mapping the first code data type representation and the second code data type representation based at least in part on the unique identifier associated with the code value issuing entity.

Abstract: Embodiments may provide a makefile interposer, which enables a makefile to be used for building software for different platforms without modifying the makefile. In some embodiments, the interposer intercepts the commands run by makefile and automatically interposes the correct library files, dependencies, paths, and other information used by make to build the program for a particular platform. Additionally, calls that the invoked tools themselves make are intercepted and the interposer may redirect them to the platform-specific tools or file system locations including redirecting file descriptors. In some instances, when a tool is called that is not in the platform, the interposer may also fall back on the other system tools.

Abstract: Systems and methods for parallelizing applications that operate on irregular data structures. In an embodiment, the methods and systems enable programmers to use set iterators to express algorithms containing amorphous data parallelism. Parallelization can be achieved by speculatively executing multiple iterations of the iterator in parallel. Conflicts between speculatively executing iterations can be detected and handled using information in class libraries.

Abstract: Systems and methods are provided for handling database deadlocks induced by database-centric applications (DCAs). SQL statements and transactions associated with the DCAs are analyzed and parsed to generate Petri net models. A supervisory modeler generates augmented Petri net models based on the Petri net models, which are used in generating supervisory control. The supervisory control is used in handling database deadlocks.

Abstract: A software application development tool provides context-based data schema code hinting. Code “regions” are defined in the code for an application that is under development. One or more data sources that are referenced by a code region may be defined. The development tool detects when a designer is attempting to reference a data schema, such as by detecting that the designer has input a specified trigger, within a region of the code, and in response, the development tool provides code hints for the data schema for corresponding data source(s) that is/are referenced in the corresponding code region in which the designer is working. Thus, rather than providing data schema code hinting for all data sources referenced by the application, targeted code hinting is employed by presenting data schema code hints for only the data source(s) that are referenced by a defined code region in which the designer is working.

Abstract: Methods and systems for facilitating incremental software development are disclosed. For example, a method can include receiving a plurality of binary software libraries sufficient for building a software project. A request from a user to modify source code for at least one of the plurality of binary libraries is received. In response to receiving the request, the source code for the at least one of the plurality of binary libraries is retrieved. The source code for the at least one of the plurality of binary libraries is presented to the user. Modified source code for the at least one of the plurality of binary libraries is received. The modified source code is compiled to produce compiled modified code. A revised version of the software project is built using the compiled modified code and the plurality of binary libraries.

Abstract: A system and method is provided for generating a RESTful communication service which offers REST2REST functionality seamlessly with automatic support for the API agnostic features such as policy enforcement, load balancing, routing, failover, logging, accounting, format conversion (XML2JSON,JSON2XML) etc. Such a system can include one or more applications, executing on one or more application servers. The system can also include a WADL plug-in which generates code for the RESTful communication service from Web Application Description Language files (WADL) which define the service interface and internal templates which define the code logic. The method offers rapid and efficient generation of REST APIs supporting API agnostic features, automatic REST API code generation from WADL files, and translation from WADL to WSDL.

Abstract: A computer-implemented system and method for creating, managing, and reusing schema type definitions in SOA services, grouped in the form of libraries are disclosed. The method in an example embodiment includes: grouping a plurality of Extensible Mark-up Language (XML) schema (XSD) types, each XSD type defined in an individual XSD file; using a processor to bundle the plurality of individual XSD types into a type library, the type library including a type information file to register the individual XSD types in the type library, the type library further including a type dependencies file to register dependencies between the individual XSD types in the same or different type library; importing types from a different type library, when defining derived types or aggregated types; generating Java artifacts from the XSD types; and associating the Java artifacts with corresponding XSD types in the type information file of the type library.

Abstract: In an embodiment, a model is sliced into a plurality of slices. A slice in the plurality of slices is selected. A portion of code, that corresponds to the selected slice, is identified from code generated from the model. The identified code is verified to be equivalent to the selected slice. Equivalence may include equivalent functionality, equivalent data types, equivalent performance, and/or other forms of equivalence between the selected slice and the identified generated code.

Abstract: Systems and methods of scalable language infrastructure for electronic system level tools. In accordance with embodiments of the present invention, knowledge about types, functions and the like is encapsulated in a plurality of intelligent components called active component extension modules that are external to the infrastructure. The infrastructure implements a communication mechanism between the clients and these intelligent components, and acts as a common backbone. The infrastructure itself does not maintain any knowledge about any client, types, functions, etc. In accordance with a method embodiment of the present invention, a request is received from a client of a language infrastructure. The request is forwarded from the language infrastructure to an active component extension module. The active component extension module performs a service responsive to the request.

Abstract: A system and method for implementing multiple versions of a plug-in concurrently are provided herein. The method includes identifying a plug-in within a multi-plug-in platform that is configured to provide a desired functionality. The method also includes executing a first version and a second version of the plug-in concurrently to provide the desired functionality, wherein each version of the plug-in is isolated from the other version of the plug-in.

Abstract: A method and system for creating data applications are disclosed. The method includes receiving a request for creating a first data application, the request including a first data application identification and a first data application type identification; obtaining a first data element corresponding to the first data application identification; and obtaining a second data element corresponding to the first data type application. The method further includes binding the first data element and the second data element to generate the first data application corresponding to the first data application identification.

Abstract: A method of translation of a chart associated with a graphical modeling environment into an input/output-extended finite automata (I/O-EFA) model is provided. The method includes receiving a representation of the chart and processing the representation of the chart with a computing device by (a) representing atomic models for each individual state of the chart, (b) applying composition rules to interconnect the atomic models while preserving state execution and transition behaviors to obtain the I/O-EFA model.

Abstract: Embodiments of the invention provide for methods, systems and computer program products for an integrated service framework with a suite of products that provide a development environment and common framework for programming within an operating system. The programmers write code to develop class plug-ins within that structure of the abstract class in order to perform services. The abstract class provides a standardized structure that may be utilized by all of programmers working within the integrated service framework to reduce redundant programs. The integrated framework also provides a service manager that identifies the class plug-ins, runs the services, logs information about the services, sends notifications to users about the services, configures itself to monitor the services, and provides communication between the services.

Abstract: The invention concerns model program analysis of software code using model checking. Initially, a transition system (22) and an extensible markup language (XML) (24) representation of the data is generated. Next, labels (26) for the transition system are generated by querying the XML representation of the data using (markup) query language. The labels and the structure of the transition system are then used as input to model checking techniques to analyse the software code (28). It is an advantage of the invention that the problem of labelling a transition system can be transformed into the XML domain so that detailed information about the software code can be extracted using queries in a format that can be run in the XML domain which are well known. At the same time the transformation to the XML domain does not prevent the use of efficient model checking technologies.

Abstract: A method for estimating a resource consumption of storage space and/or of required runtime of a control device program code to be generated for a control program, whereby the functionality of the control program is given in an executable model. The model has a function with first functional magnitudes and first information associated with the first functional magnitudes and optimization parameters for optimizing a code generator. A program code representation is generated for part of the model comprising the function by the code generator taking into account first values of the optimization parameters. An estimation unit comprises a resource model with hardware parameters. An estimated value for the storage space requirement is determined for the control device program code and/or a runtime estimated value is determined for the control device program code by the estimation unit taking into account the hardware parameters and based on the program code representation.

Abstract: A client-side integrated development environment (IDE) may rely on an application server for certain processing tasks, such as generating code or other output using server-side templates. The client-side IDE can itself be configured through use of the application server to handle events generated in the client-side IDE. This may allow developers to easily add and/or change IDE functionality without the need to be familiar with the IDE software architecture or programming language.