Abstract: The disclosed methods, mechanisms, and system provide the ability to associate one or more disjointed models such that a second model can be accessed from a first model thereby allowing easier navigation between models. A graphical link to a second model is provided as part of a first model. Activating the graphical link opens the second model for viewing or editing. Links between additional models may also be provided. Thus, by using the provided graphical links, a user may quickly and easily navigate between all the associated models.

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: A computer system identifies a uniform resource identifier (URI) that corresponds to a resource of a RESTful web service. The URI contains elements. The computer system identifies a relationship between the elements of the URI and creates programming code for a method of a software development kit (SDK) client. The method reflects the relationships between the elements of the URI to facilitate communication with the resource of the RESTful web service.

Abstract: Embodiments of the invention provide a platform-independent application development framework for programming an application. The framework comprises a content interface configured to provide an Application Programming Interface (API) to program the application comprising a programming code to be executed on one or more platforms. The API provided by the framework is independent of the one or more platforms. The framework further comprises an application environment configured to provide an infrastructure that is independent of the one or more platforms and one or more plug-in interfaces configured to provide an interface between the application environment and the one or more platforms.

Abstract: This disclosure provides techniques of verifying license compliance for a web application. A web application including a broadcast key and a license tag is generated. The generated web application is made available for review by a search engine. A query is communicated to the web search engine for a selected license tag. A list of reviewed web applications is received from the web search engine. The broadcast keys associated with each web application are evaluated to identify duplicate broadcast keys.

Abstract: A system including spreadsheet sheets, makes calculations and data transformations, which is available through a programming interface, and conforms to the grammar and syntax of a target software development language is presented. The system includes an Object Model with Data Structures representing entities involved in spreadsheets. The system includes a Parser and Code Generator that extracts data from a body of spreadsheet data, instantiates instances of Data Structures of the Object Model to represent the spreadsheet data, parses the data and formulas contained in the cells of the spreadsheets, iterates through the instantiated instances of the Data Structures, and generates source code that performs the calculations and data transformations embodied in the spreadsheet data. The system includes a Calculation Engine with software base classes that implement the common structural and data access features of spreadsheet data, and further implement the operations of common spreadsheet functions and operators.

Abstract: Development tools are disclosed that connect various artifacts in a database aware fashion. For example, the development environment may integrate SQL query builders across multiple application development interfaces (e.g., a source code editor, XML editor, database scripting tools, etc.), significantly improving developer productivity, reducing development cost and time. Thus, the process of consuming heterogeneous artifacts in an application (or creating them for consumption) becomes a very productive experience, eliminating the need to manually cut/paste information in multiple project files in many cases.

Abstract: A computer-readable medium, computer-implemented method, and financial close management system are provided that manage a schedule. A schedule is a core object of the financial close management system, and is an expression of a template. Managing a schedule can include creating a new schedule, modifying an existing schedule, deleting an existing schedule, duplicating an existing schedule, validating an existing schedule, creating a template from an existing schedule, setting a status of an existing schedule, and importing and exporting an existing schedule. In addition, managing a schedule can include defining task type parameters that can be set during scheduling and setting task parameters of a schedule at a schedule level rather than a task level.

Abstract: Systems and methods for dynamically generating computer executable technical support procedures, as well as updating/augmenting such executable procedures, by tracking and processing sequences of actions (execution traces) that are taken by experts (or users) when performing a procedure or when executing an executable procedure.

Abstract: An aspect includes a method for policy to source code conversion. Policy information is received in a natural language format. Class generator data, including a plurality of classes and relationships between the classes, is accessed. A computer processor identifies at least one class in the plurality of classes and at least one data value associated with the at least one class in the policy information. The identifying is based on the class generator data. The computer processor creates an instance of the at least one class and generates source code from the instance of the at least one class. The source code is configured to create a subsequent instance of the at least one class.

Abstract: Aspects of the present disclosure extend to methods and systems for providing computing environments as a service. In various aspects, hardware and/or software resources are automatically provisioned or otherwise allocated to support the different phases of a software development project. One or more interfaces may be accessed that allow for the selection and/or configuration of the various hardware and/or software resources corresponding to a software application and its current computing environment. The configured resources and source code may be provided as a service to users.

Abstract: Methods and computer program product relate to user input auto-completion. The methods and product are executable on a processing device in a computing system environment so as to provide an auto-completion scheme with enhanced capabilities that improve user efficiency when performing a task.

Abstract: System(s) and method(s) are provided for implementing a set of interface components across a set of layers of an industrial environment, and for managing at least one interface component or at least one layer of the industrial environment. To implement an interface component in at least one layer in the set of layers, a specification that defines the interface component is acquired and, based at least on the specification, a service is generated. Execution of the service implements the interface component. The managing includes deploying or discovering the at least one interface component or the at least one layer of the industrial environment. The managing also includes indexing specific functional feature(s) of the at least one interface component and searching across the set of layers for one or more interface components that satisfy specific functional criteria. Moreover, the managing can include supplying metadata related to interface component(s) or layer(s).

Abstract: An application registers a first component used by the application with a customizing mechanism, and a component setting unit notifies the customizing mechanism of a second component corresponding to the first component. In accordance with changeover of the second component corresponding to the first component by the component setting unit, the first component executes process using the second unit after the second unit has been changed over.

Abstract: The disclosure provides a system, a method and a computer program product that facilitate access to one or more applications by a computing device. The disclosure includes a step of determining one or more contexts associated with the computing device or a user of the computing device, such that the one or more contexts describe environment or activity of the user or the computing device. The disclosure also includes a step of generating at least one contextual tag corresponding to the one or more contexts, after which the one or more applications associated with the at least one contextual tag are identified and the computing device is enabled to access the one or more applications.

Abstract: Embodiments of the invention introduce development tools that connect various artifacts in a database aware fashion. For example, embodiments of the invention integrate SQL query builders across multiple application development interfaces (e.g., a source code editor, XML editor, database scripting tools, etc.), significantly improving developer productivity, reducing development cost and time. Thus, the process of consuming heterogeneous artifacts in an application (or creating them for consumption) becomes a very productive experience, eliminating the need to manually cut/paste information in multiple project files in many cases.

Abstract: According to some embodiments, a method and apparatus are provided to receive an application type and a platform environment type. An application based on the received application type and the platform environment type is created. The application comprises an instantiation of the received application type configured for the received environment type.

Abstract: Provided is an information processing apparatus including a program execution unit configured to read, interpret and execute a code of a computer program that is created in a procedural language, and a backup unit configured to create a backup in a format in which a variable definition and a function definition in the code being executed by the program execution unit are interpretable as a code in the procedural language.

Abstract: A method is provided for interacting with the graphical model is provided. At least one of the plurality of views of the graphical model is parsed to create an intermediate representation. An interactive overlay is displayed using the display device. User interacts with the destination object based on an input instruction via the interactive overlay and modifies the destination object using the input instruction, the modifying allows the destination object to perform a modified operation when the model is executed. The graphical model includes execution semantics and a destination object, where the destination object is influenced by the execution semantics. The graphical model is rendered on a display device based on a selected view.

Abstract: A single software project can include heterogeneous types of artifacts. The artifact definition can be converted to a format compatible with a common model or information derived from the artifacts can be added to the common model so that tools that operate on the common model can provide information derived from the heterogeneous artifacts to developers during design time in an IDE. Build and deployment tools can operate over a more inclusive universe of data to provide a more accurate deployment plan. Build and deployment tools can operate within the context of the IDE or from the command line.

Abstract: Apparatus, systems, and methods for a compiler are described. One such compiler converts source code into an automaton comprising states and transitions between the states, wherein the states in the automaton include a special purpose state that corresponds to a special purpose hardware element. The compiler converts the automaton into a netlist, and places and routes the netlist to provide machine code for configuring a target device.

Abstract: Preparing a computer software application for static analysis by identifying a control flow within a model portion of a computer software application having a model-view-controller architecture, where the control flow passes a value to a controller portion of the computer software application, analyzing a declarative specification of the controller portion of the computer software application to identify a view to which the controller portion passes control based on the value, and synthesizing a method within the computer software application, where the method calls the view.

Abstract: A method performed by one or more processing devices includes receiving a request to generate a computer program; generating, in response to receiving the request, a first user interface that when rendered on a display device renders: one or more first visual representations of one or more first fields of the first resource; and one or more second visual representations of one or more second fields of the second resource; receiving, through the first user interface, a selection of: at least one of the one or more first visual representations; and at least one of the one or more second visual representations; receiving, through a second user interface, data specifying the one or more operations; and updating, based on the received data, the computer program with one or more third instructions to perform the one or more operations.

Abstract: A method, computer program product, and system for determining release differences is described. A method may comprise determining a first difference, the first difference corresponding to one or more activities that were at least one of: added to a main branch between a first release branch and a second release branch, and removed from the main branch between the first release branch and the second release branch. The method may further comprise determining a second difference, the second difference corresponding to one or more activities that were at least one of: added to the first release branch, and removed from the first release branch. The method may additionally comprise determining a third difference, the third difference corresponding to one or more activities that were at least one of: added to the second release branch, and removed from the second release branch. A delta activity set may be determined.

Abstract: A software application platform that abstracts a computing platform, a database layer, and a rendering medium is disclosed. A platform-independent application programming interface is disclosed, as well as an abstract database layer. The abstraction of the database layer comprises two sub-layers, including a layer having a uniform interface that treats data records as plain objects and a layer having constructs that facilitate the automated generation of user interfaces for data record navigation and management. Further, a software application platform that is independent of rendering medium is disclosed.

Abstract: A computer system may provide various resources to users through one or more programming libraries, such as application programming interfaces (APIs), in order to standardize access to such resources through various general-purpose mechanisms. These programming libraries may be operated by other programs, such as task-specific user interfaces, through which a user may utilize the programming library without having to understand its structure and functions. However, in many scenarios, a user may wish to know the manner of invoking a programming library to achieve an invoked behavior, or may wish to reproduce the behavior without having to utilize the user interface. A user may therefore capture an invocation of the programming library, and may generate an instruction set representing the captured invocation that may be studied, copied, modified, subsequently performed, etc.

Abstract: A transformation tool and a validation tool are used to verify programmable artifacts, such as Java models, that are generated from an original ontology model. The verification process ensures that the programmable artifacts are semantically equivalent to the original ontology model from which they are created. Each element in the programmable artifacts is tagged with appropriate metadata, using, for example, Java language annotation support. Once tagged, the programmable artifacts can be parsed to form a generated ontology model. This generated ontology model can then be compared to the original ontology model with a validation tool, in order to verify their semantic equivalence.

Abstract: Embodiments described herein relate to systems and methods for displaying aggregated stack traces in a source code viewer. One or more execution identifiers are received in response to an execution of a first program executing on one or more client computing devices. Each execution identifier can include one or more stack frames, which correspond to a function call within the first program. An error-likeliness score is identified for each execution identifier. An error-weight is determined for each of the execution identifiers based on the identified error-likeliness scores for instances of the execution identifiers.

Abstract: The present invention provides a mobile application ecosystem comprising a mobile application development kit and store, both of which are implemented as web-based services such that creation, testing, and distribution of mobile applications, as well as discovery, investigation, and delivery of same, can all be performed using a standard web browser. The mobile application development kit offers common capabilities across all target mobile device brand and brand groups, allowing the same application construct to work unmodified on all, while building the application in a manner that is native to each, thereby avoiding any requirement to embed a separate common runtime or virtual machine on every mobile device.

Abstract: An application server is described for development of telecommunications-based software applications. The application server provides a protocol-neutral programming model for application developers. Rather than having to account for specific protocol entry points into the server, all interactions in the server are abstracted as asynchronous events through the event broker layer. State management and concurrency are implemented as an actor-based model, where each actor owns its own segment of state and other actors wishing to update that state send asynchronous events to the owner. Thus, any communication in the various protocols can be expressed as an asynchronous event passed to, from and between the actors, who are each responsible for maintaining their own segment of state locally.

Abstract: Embodiments relate to generating short displacement instructions. An aspect includes performing code generation by a compiler to generate an instructions. Another aspect includes determining whether the generated instruction supports long displacement. Another aspect includes based on a determination that the generated instruction does not support long displacement, determining whether a short displacement budget is full. Another aspect includes based on a determination that the short displacement budget is not full, marking data associated with the instruction in a symbol table maintained by the compiler. Another aspect includes incrementing the short displacement budget using a size of the marked data associated with the instruction. Another aspect includes based on a determination that the short displacement budget is full, performing a low cost fix up.

Abstract: A method and device for the programming and configuration of a programmable logic controller are disclosed. The method can include: locating a configuration tool in a programming tool, wherein the configuration tool includes a module in an IEC61131 language; integrating at least one further module into the configuration tool, and executing the programming and configuration of the programmable logic controller in a high-level language using a C-Code editor, and wherein the at least one further module is configured to provide a definition of interfaces between an IEC61131 code and a high-level language code, and provide a configuration of the high-level language code.

Abstract: A website optimisation system is integrated with a website by applying generic code to the website, that being the only code needed to be applied to the native source code of the website to enable the website optimisation system to optimise the website by altering one or more of: the data, functions or content assets of web pages in the website. Integration can be achieved on a one-time basis. The generic code can be placed into a website's page template or global page header, or manually to all pages in a website. The generic code can be just a single line of code, such as JavaScript code. The generic code remains the same irrespective of any differences in the data, functions or content assets of the web pages. The generic code includes code for all commands that enable tracking of the actions that relate to the optimisation objectives.

Abstract: A system and method for computational unification of heterogeneous implicit and explicit processing elements which supports the aggregation of any number of such processing elements. The system and method of the present invention supports the generation of a unified executable program through the use of directive statements which are analyzed in conjunction with the semantic structures in the parsed source code to generate appropriate source code targeted to the implicit and explicit processing elements. The computational unification system and method of the present invention further embodies expertise with the particular programming style and idiom of the various processing elements.

Abstract: An architecture for creating a plasma-processing-related application is provided. The architecture includes a foundation layer having a plurality of framework components, wherein the framework components including at least one of security component, data management component and user interface (UI) component. The architecture also includes an analysis view layer having a set of views, wherein the set of views are generated utilizing components from the foundation layer. The architecture further includes an analysis module layer having a plurality of analysis modules, wherein each analysis module of the plurality of analysis modules is assembled from one or more view of the set of views. The architecture moreover includes an application layer having a plurality of applications, wherein each application of the plurality of applications is assembled from one or more analysis module.

Abstract: A method and a system for automatically synchronizing the design features of disparate but conceptually corresponding code elements (e.g., image representations) within disparate but potentially composable code components (e.g., frameworks and their payloads). For example, an element that is a field within a structure that points to an abstract image BP within a skeletal framework component may conceptually correspond to a simple element that is a concrete image B within some intended framework payload. In the composition of the framework and the computational payload, the concrete image B must acquire the design features of the abstract image BP (i.e., a pointer within a structure field) to be properly synchronized with the design of the framework. This invention automates differencing of composite types to compute transformations that can add design features to B to convert it to BP thereby synchronizing the design features of the framework and its payload.

Abstract: A processor-implemented method, system, and/or computer program product maintain integrity of output of a code generator. One or more processors determine a generated output that has been generated by a specific code generation application based on an original model, where the original model is a structured model used to construct a software program. The generated output is analyzed to infer contents of an inferred version of the original model. The inferred version of the original model is compared with a current version of the original model to detect differences in source elements. Detected differences are thus used to identify redundant elements in the generated output.

Abstract: Described are techniques for generating a parser. A graphical representation of a finite state machine is provided for determining whether an input is syntactically valid in accordance with a syntax represented by the graphical representation. A second representation is generated which corresponds to the graphical representation. Using the second representation, a parser is generated for parsing an input. The parser determines whether the input is syntactically valid in accordance with the syntax.

Abstract: A computer program including an interface that may be used by a content designer to manipulate information stored in the database. The content designer may design one or more questionnaire pages, to be included in a questionnaire site, which may be built into a questionnaire interface program by a compiler. The resulting questionnaire interface site may be accessed and manipulated by a client user to respond to the questions included therein. Validation responses may be defined by a content designer, against which responses by a client user may be compared. The various elements included herein may be connected through a network, which may be accessed through a user interface terminal.

Abstract: A system, method and database development tool are disclosed for automatically generating parameters for use in executing a stored code object in a data base, by parsing source code derived nom existing data base code which represents the stored code object, wherein the parameters may represent complex data types.

Abstract: A system, program storage device, and method of buffering an electronic document received from a host computer, wherein the method comprises determining whether an original source code of the electronic document includes executable coding which when executed by a client computer, causes the client computer to perform undesired operations, and producing an alternate source code of the electronic document, which eliminates the coding, wherein the undesired operations are characterized as undesirable based on predetermined settings established by the client computer. The electronic document comprises any of a web page, electronic mail message, an electronic mail attachment, a note in a hypertext format, a text document, a text file, and an application-specific electronic document. Each of the original source code and the alternate source code comprises a hypertext transfer protocol (HTTP) source code.

Abstract: Embodiments are directed to declaratively managing software applications, dynamically applying configuration changes to a specified software application based on a service level objective (SLO) and to efficiently performing an impact analysis for a specified service level agreement SLO.

Abstract: Generating an instruction set for an architecture. A hierarchical description of an architecture is accessed. Groups in the hierarchical description that can be pre-encoded without increasing final width of said instruction set are pre-encoded. The hierarchical description is permutated into a plurality of variations. Each variation comprises a leaf-group and one or more sub-graphs to be encoded. For each said variation, the leaf-group and the one or more sub-graphs are encoded to produce a potential instruction set for each variation. One of the potential instruction sets is selected.

Abstract: A code generator and multi-core framework are executable in a computer system to implement methods as disclosed herein, including a method for the code generator to automatically generate multi-threaded source code from functional specifications, and for the multi-core framework, which is a run time component, to generate multi-threaded task object code from the multi-threaded source code and to execute the multi-threaded task object code on respective processor cores. The methods provide transparency to the programmer, and during execution, provide automatic identification of processing parallelisms. The methods implement Consume-Simplify-Produce and Normalize-Transpose-Distribute operations to reduce complex expression sets in a functional specification to simplified expression sets operable in parallel processing environments through the generated multi-threaded task object code.

Abstract: A compiler and method of optimizing code by partial inlining of a subset of blocks of called blocks of code into calling blocks of code. A restart of the called blocks of code is provided for the case where non-inlined blocks of code are reached at run time. Blocks selected for partial inlining may include global side effects depending on the computer program environment. Global side effects in the selected blocks of code leading to a restart are sanitized in order to defer changes to the global state of the computer program.

Abstract: Described are a method and apparatus for generating software tools used in model-driven development of software. An input model is provided for a first pattern used to generate an artifact associated with a recurring solution. A set of one or more modifications is defined. The set is to be applied to a schema for the input model in order to produce a user model. The set of modifications is received as input to a second pattern. In response to the received set of modifications, program code is generated for implementing a user interface based on the user model and for performing a model-to-model transformation of information from the user model to the input model.

Abstract: A Dynamic Web Service server may facilitate custom Enterprise Application interface development with little or no developer input by dynamically creating a web service for performing a particular transaction according to a transaction map. An Enterprise Application client device may create a transaction map by “recording” a transaction between an Enterprise Application client and an Enterprise Application server and mapping transaction fields to a custom interface generated to collect data for re-performing the recorded transaction. The Enterprise Application client device may call the dynamic web service, and the Dynamic Web Service server may then perform the recorded transaction using input data collected in the custom interface.

Abstract: A primary file can be used to specify default build properties for software under development. A set of modified build properties may be stored in a supplemental file. The default build properties can be temporarily overridden with modified build properties for a given build, allowing freedom in the choice of build properties without proliferation of files used for the same purpose, which can be confusing. In addition, users can create new build commands for software under development, and associate the new commands with supplemental files. When the user invokes a new build command, the build process can override the default properties with the modified properties in the supplemental file, and then restore the defaults. Other advantages and features of the invention are described below.

Abstract: In one aspect, a spellchecker is provided that differentiates between code and natural language parts of a source code file. In operation, the spellchecker identifies a string in the source code file and attempts to classify the string as inducing programming language instructions or natural language words. If the sting is classified as including natural language words, the spellchecker outputs an indication of a spelling mistake in the string. Otherwise, if the string is not classified as including natural language words, the spellchecker does not output indications of spelling mistakes found in the string.

Abstract: Techniques for presenting a modal dialog box in a graphical user interface are described herein. According to one embodiment, a semi-transparent panel is displayed superimposed on a graphical user interface (GUI) page in response to a first user interaction with the GUI page. The GUI page provides a user interface for managing a virtualization system. A dialog box is then displayed on top of the semi-transparent panel, where the dialog box is to receive an input from the user. An alert is generated in response to a second user interaction with an area of the semi-transparent panel other than the dialog box, where the alert indicates that the second user interaction is invalid. Other methods and apparatuses are also described.