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: 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: 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: 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: 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 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: 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: 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 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: 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: 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 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.

Abstract: Development of data services can be enhanced through the use of methods and systems that automate aspects of the build process. Particularly, software can be used to automatically generate test cases and incorporate test results into documentation as part of the build process based on an updated Application Programming Interface (API) specification to generate up-to-date and accurate Software Development Kit (SDK) artifacts. A method can comprise accessing data defining an API for a data service, such as Web Application Description Language (WADL) or Web Service Description Language (WSDL) data. The method can further comprise identifying a test case for a service call that can be made via the API based on the data defining the API, and generating test code, the test code configured to evaluate the test case by making the service call. The test code can be used for evaluating the test case(s) in order to ensure requests and/or responses are consistent with the API definition.

Abstract: Embodiments include a method comprising providing a design interface that depicts a plurality of interface elements of an application under development, each element defined in source code accessible by the application development environment in a declarative markup language. The method can comprise receiving, through the design interface, data representing a selection of a plurality of the interface elements, identifying the declarative expressions corresponding to the selected interface elements, defining a new declarative expression, and generating at least one code segment using the identified declarative expressions. The method an comprise storing the generated code segment in a computer readable medium, with the stored code segment associated with the new declarative expression, so that the new declarative expression can be inserted into the source code in place of the identified declarative expressions and/or can used in a second application under development.

Abstract: A method for transforming a procedural program having procedural language code into an object-oriented distributed software program is provided. A procedural program is transformed into intermediate client-server code. The intermediate client-server code is partitioned into an N-tier application program.

Abstract: Software development for a hybrid computing environment that includes a host computer and an accelerator, the host computer and the accelerator adapted to one another for data communications by a system level message passing module and by two or more data communications fabrics of at least two different fabric types where software development includes creating, by a programmer, a computer program for execution in the hybrid computing environment, the computer program including directives for generation of computer program code that moves contents of memory among host computers and accelerators in the hybrid computing environment; generating, by a code generator application, source code in accordance with the directives; analyzing, by the code generator application, operation of the generated code for data movement and utilization of moved data; and regenerating, by the code generator application, the source code in accordance with the directives and further in accordance with results of the analysis.

Abstract: Techniques are provided for automatically generating Application Programming Interfaces (APIs) in a computing device. In one example, a request for the addition of a first API to a software infrastructure of a computing device is received. An API coding table that includes one or more initial API parameters corresponding to the first API is generated and an API coding template stored in memory of the computing device is obtained. A compiler of the computing device generates functional codes for the first API based on the API coding template and the initial API parameters.

Abstract: A method keeps a web session alive for an amount of time allowing to keep a limited amount of data on the Internet information server and manage individually the session timeout characteristics of the web session in the web application. The method automatically refreshes the web pages in the background without any further user interaction. Thereby, a portion of code added effectively creates a hidden postback that keeps alive the session's state. By a class library, the user is enabled at the engineering level to manage a session timeout state and to eliminate a premature timeout thereby eliminating any risk of possible data loss.

Abstract: A method, apparatus, and/or computer program product generates a predictive data structure for an application when operating offline in a network connected data processing system, the application comprising source code having an execution path. The method comprises: determining an exit point within the source code of the application; determining, from the exit point, an execution path comprising at least one conditional statement; identifying one or more branches of the at least one identified conditional statement and for each identified branch determining an expected response; for each determined expected response, generating a data structure from the response; continuing along the execution path of the source code from the exit point and replacing each request for a resource in the source code with a pointer to the generated data structure; and executing the source code with the pointer to the generated data structure from the determined exit point.

Abstract: Business rules may be harvested from software using automated processes and used in developing new computer software. Automated harvesting may speed up development, reduce cost, and decrease human error during software development. Harvesting the business rules from computer software may also allow business analysts to verify and update business rules. The business rules may be harvested by parsing existing source code into abstract syntax trees (ASTs). The source ASTs may then be transformed into target ASTs corresponding to a programming language different from the existing source code. Those target ASTs may then be recomposed into output source code of the different programming language.

Abstract: The disclosure herein relates to systems and methods for creating or updating applications using content from a pre-existing application, and in particular, utilizing content of a pre-existing application to create or update mobile applications and web applications including HTML 5 applications. An input may be received that identifies a pre-existing application to be utilized in creating or updating an application. One or more application modules may be derived from the content of the pre-existing application. The application content may be analyzed in accordance with a rule set to detect application features associated with the pre-existing application. The application features may be incorporated into the one or more application modules. The application modules may then be compiled into an application such as a mobile application or HTML 5 application.

Abstract: Techniques to perform code separation with semantic guarantees are described. When porting a software application to a different target architecture and potentially to a different set of platforms and programming languages, application functionality will change based at least to accommodate architectural differences. However, business logic should be guaranteed to be semantically preserved, efficiency optimized to the platform benefits and limitations. Code separation identifies candidate components, associates the candidate components with a component classification or type, and automates the determining of which of the candidate components are to be associated with various portions of the target architecture. Automated code separation may include various inference algorithms to determine which components are to be associated with a component type. Also described are various use cases for code separation.

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 integrated service framework 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. The service manager may act as the service installer to install and run the class-plug in. The service manager allows the service to communicate to the client application through the use of a common format. The service manager may also be self-adjusting, such that the service manager may change interval commands to prevent common notification errors from occurring.

Abstract: A technical computing environment may include a modeling component to facilitate construction of a model and a code generation component. The modeling component may include an input component to receive one or more input signals through an interface protocol, and one or more components to receive one or more parameters, corresponding to the input signals received using the interface protocol, and to operate on the one or more parameters. The code generation component may include a code generator to generate, from the model, programming code compatible with a target environment, and an output interface to output the programming code.

Abstract: An input unit of a compiler accepts a second program called by a first program. A converting unit of the compiler converts the accepted second program into a program in which an initialization instruction and a return instruction are additionally written as instructions executed when an error occurs. An execution control unit of an execution controller executes an execution file having the program where the instructions are additionally written by the compiler in cooperation with a predetermined function group. If an error occurs, an error processing unit of the execution controller initializes a resource based on the initialization instruction described in the program in the execution file having the error, and returns to a caller program based on the return instruction.

Abstract: A method, a system, and a WEB client for editing scripting language based on WEB are disclosed. The method including: querying a server about available object in a current script usage scenario, and its attribute and method; generating a script editing interface according to the queried available object and its the attribute and method, and displaying a script content input by an inputting device in the editing interface; acquiring confirmation identifier of the edited content, and checking whether or not the script content before the confirmation identifier is an indication object capable of automatically indicating; if so, acquiring, from the attribute and method of the available object, an attribute and method related to the indication object, and displaying them on a prompt box formed in the script editing interface for selection; and adding the attribute and method of the indication object selected from the prompt box after the indication object.

Abstract: Implementations of the present disclosure are directed to for checking that a to-be-compiled program is well-typed such that the program is secure in a semi-honest model, and include actions of receiving the program, the program being provided in a human-readable, domain-specific programming language and including two or more protocols to provide secure computation based on inputs provided by two or more parties, processing the program in view of a type system to determine whether the program is secure in the semi-honest model, the type system including a secure type system extension provided as a set of typing rules that describe security types that can be assigned to one or more entities of the program, and compiling the program to generate a computer-executable program in response to determining that the program is secure in the semi-honest model.

Abstract: A memory map wrapper may be used to provide an interface between a model and a system with which the model interacts. The memory map wrapper may be designed to provide an interface for source code implementing the model. The memory-map wrapper may include a source code section that describes a mapping between memory regions corresponding to first and second sets of signals and between the source code implementing the model, the mapping defined using macros in memory map wrapper code in which configuration information describing the first and second signals is provided as one or more parameters associated with the source code section. Additionally, a preprocessor component may expand the macros in the memory map wrapper code based on the provided one or more parameters to output expanded memory map wrapper code.

Abstract: Implementations of the present disclosure include executing a business application on a server device, the business application executing a service based on a base plurality of inputs, accessing a first service variant based on the service, generating a first plurality of input fields based on the first service variant, the first plurality of input fields corresponding to a first plurality of inputs, the first plurality of inputs being a sub-set of the base plurality of inputs, and executing the service based on the first plurality of inputs that is input using the first plurality of input fields.

Abstract: A method for generating a transport track for routing transport requests through a software system landscape comprising a central control system and a plurality of logical systems interconnected by logical transport paths, a transport request defining a software service to at least one of the code and the data of a system in the landscape, is described. The method includes selecting a group of systems for a software service project according to a project definition; analyzing in the central system the transport paths between the systems of the group for finding a suitable route through all systems of the group; and generating in the central system a transport track according to the analysis, the transport track defining a route for transport requests through all systems of the group in a particular order, the transport track specifying one source system in which software services are permitted, pairs of adjacent interconnected systems, and at least one target system.

Abstract: Techniques are disclosed for generating embeddable widgets capable of accessing contents in a cloud-based platform. In one embodiment, a method comprises receiving a request identifying a target content in the cloud-based platform. The method further comprises automatically generating a plurality of software codes which correspond to a software widget that enables access to the target content. According to some embodiments, the software widget is to be embedded in a software product so as to enable a user of the software product to access the target content without navigating away from the software product. Among other advantages, embodiments disclosed herein provide easy integration of centralized contents to users and third-party web-service vendors, and reduce the effort necessary for system administrators in controlling data security and tracking different activities performed to the centralized content, thereby enabling more intuitive user experience without sacrificing data security.

Abstract: The disclosure relates generally to autonomous generation of software documentation, and more specifically to autonomous generation of documentation that describes user-defined rules implemented for a computer management system. In one embodiment, a system for generating documentation comprises a database storing user-defined rules that specify management actions to be triggered, for managing a computer system, responsive to receipt of a system message from the managed computer system. The system further comprises a documentation generation device configured to autonomously generate documentation describing the rules, wherein the documentation contains identification of at least the system message and the corresponding management actions triggered by the rules upon receipt of the system message.

Abstract: Methods, systems, and computer-readable media include actions for composing non-functional concerns to be implemented with an application. In implementations, actions include receiving a requirements model that defines non-functional requirements and non-functional attributes associated with the non-functional requirements, for each non-functional attribute, identifying one or more actions, properties of each action and interdependencies between actions to provide an action model, defining an action composition model based on the action model, the action composition model defining orders of execution of actions and one or more activities, defining an action mapping model, the action mapping model mapping actions and activities to the application, generating computer-executable code based on the action mapping model, the computer-executable code being executable to provide a non-functional concern.

Abstract: A computer-implemented method for creating a program for a multi-processor system comprising a plurality of interspersed processors and memories. A user may specify or create source code using a programming language. The source code specifies a plurality of tasks and communication of data among the plurality of tasks. However, the source code may not (and preferably is not required to) 1) explicitly specify which physical processor will execute each task and 2) explicitly specify which communication mechanism to use among the plurality of tasks. The method then creates machine language instructions based on the source code, wherein the machine language instructions are designed to execute on the plurality of processors. Creation of the machine language instructions comprises assigning tasks for execution on respective processors and selecting communication mechanisms between the processors based on location of the respective processors and required data communication to satisfy system requirements.

Abstract: In a model editing apparatus, a model transformation function transforms SM (source model) 0 into TM (target model) 0, and generates TDM (transformation dependency model) 0. Moreover, when an SM editor generates SM1 by updating SM0, the model transformation function transforms SM1 into TM1 and generates TDM1. When a TM editor generates TM0_n by editing TM0 independently of the change in SM0, a Change element registration function registers a difference ?2 between TM0 and TM0_n in TDM0, thereby generating TDM0_n. Then, in response to a call, a merge function merges a difference ?1 between TDM0 and TDM1 extracted by a ?1 extraction function, and a difference ?2 extracted from TDM0_n, according to prestored processing patterns.

Abstract: In an embodiment, a class definition of a class may provide an indication whether a property, which is part of the class, is immutable. The indication may be made implicitly or explicitly. A value of the property may be established (e.g., set) during a creation of an instance of the class. An attempt to set the value of the property after the instance is created may be disallowed. Further, an error (e.g., an error message, exception condition) may be reported in response to disallowing the attempt.

Abstract: A quantified belief propagation (QBP) algorithm receives as input an existentially quantified boolean formula (QBF) of existentially quantified boolean variables, universally quantified variables, and boolean operators. A tripartite graph is constructed, and includes (i) there-exists nodes that correspond to and represent the existentially quantified variables, (ii) for-all nodes that correspond to and represent the universally quantified variables, and (iii) sub-formula nodes that correspond to and represent sub-formulas of the QBF. A set of boolean values of the existentially quantified variables is found by (i) passing a first message from an arbitrary sub-formula node to an arbitrary for-all node, and (ii) in response, passing a second message from the arbitrary for-all node to the arbitrary sub-formula node.

Abstract: A relational model may be used to encode primitives for each of a plurality of threads in a multi-core processor. The primitives may include tasks and parameters, such as buffers. The relationships may be linked to particular tasks. The tasks with the coding, which indicates the relationships, may then be used upon user selection to display a visualization of the functional relationships between tasks.

Abstract: A method and system for providing a web platform configured to assist in a development of a web application. The method includes developing a core layer of a web development software stack including first bundles organized into a first bundle group by an underlying web framework, developing a ket layer of the web development software stack including second bundles organized into the first bundle group by the underlying web framework, developing an application layer of the web development software stack including third bundles organized into a second bundle group by the underlying web framework, and allowing modification of code for each of the core layer, ket layer and application layer exclusively by web developers having a respective classification of a plurality of different classifications. The system includes various hardware components configured to perform the method for providing the web platform.

Abstract: The present invention relates to method of defining multiple program abstractions, extraction methodologies, transformation, and code conversion to convert legacy monolithic architecture of business systems to a layered modern architecture using Object Oriented language such as Java.

Abstract: Device simulators and methods for using the same are disclosed. In some embodiments, the device simulators are capable of permitting accurate pixel to pixel and inch to inch mapping between a simulated display and a display of a target device. Web application development tools utilizing such simulators are also disclosed. In some embodiment, such web application development tools provide a convenient method to convert electronic document source files to interactive document web applications for multiple operating systems and form factors.

Abstract: A device receives a model that includes model elements scheduled to execute in time slots on a hardware device. The device identifies time slots, of the time slots, that are unoccupied or underutilized by the model elements, and identifies a set of model elements that can be moved to the unoccupied time slots without affecting a behavior of the model. The device calculates a combined execution time of the model elements, determines whether the combined execution time of the model elements is less than or equal to a duration of a first time slot of the time slots, and schedules the model elements for execution in the first time slot when the combined execution time of the model elements is less than or equal to the duration of the first time slot.