Abstract: Methods, systems and computer readable media for automatically generating customizable user interfaces using programming patterns are disclosed. According to one method, application objects of an application computer program are analyzed to identify programming patterns. Each programming pattern is a relationship among signatures of application methods in one of the application objects. The signatures of the application methods include public interfaces of the application methods. A user interface is automatically generated for the computer program. Automatically generating a user interface includes providing for at least one of a user and a programmer of the computer program to customize mappings between the application objects and user interface elements, where the user interface elements include at least one of user interface widgets and speech grammar rules.

Abstract: Described is a technology in a programming (development and/or runtime) environment by which data type mismatches between the output and input of computer program software components (e.g., APIs) are detected, with the output transparently converted such that the converted input may be understood by the inputting component. When components are interconnected in a programming environment, metadata associated with those components is evaluated to determine a type mismatch, e.g., between objects and arrays. If mismatched, an output object is converted to a single-element array for input, or alternatively, an output array is converted to a series of objects, each object sent within a loop for input. The transparent conversion may be performed by the programming environment during runtime, or by inserting conversion code prior to compilation.

Abstract: According to aspects illustrated herein, a system, a method, and a machine-readable medium for designing business process applications is provided. The system includes: an application design interface and an object query language module. The application design interface provides an integrated development environment framework. The object query language module is operatively connected to the application design interface and a data source such that data flows between the application design interface and the data source.

Abstract: Facilitating translation of data between object oriented programs and database storage tables. A method includes receiving user input from a user. The user input includes a plurality of parts. Each part includes a specification of a source (such as a type source), optionally a filter, and a projection. Each projection assigns values to table columns. Based on the plurality of parts received, the method includes generating one or more views. The one or more views describe relationships between model extents and database tables.

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: In various aspects, a system and method for structuring and interpreting organic computer programs may provide for programs to expand, grow and evolve analogous to the way plants, animals, and organisms in nature grow and evolve. The organic computing system and method may unify program design time and program run time, may provide for program structure and program state to change at run time, and may provide for programs to continuously change and evolve through the addition of member functions, inputs, and outputs as the program is running. The organic computing system provides continuous means of differentiation, creating asymmetries and the opportunity for competition, and integration, creating symmetries and the opportunity for cooperation.

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: 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: The object file format and linker are enhanced to provide file attributes to allow flexible selection and placement of objects.

Abstract: A plurality of domain-specific service adaptation languages can be supported by a back-end service adaptation system to provide runtime access to a runtime instance of a data object comprising data stored in a repository. By defining a language-specific data access service and parser for each domain-specific service adaptation language, a single, service adaptation language-independent compiler and interpreter can prepare and execute a runtime load that includes an execution plan for retrieving and converting data from the repository for delivery in a data object according to a query request from a consumer runtime environment. A consumer using the consumer runtime environment can define the service adaptation language to be used and provide a parser and source code to enable access to business object data using the back-end service adaptation system.

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: 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: An object oriented programming environment with an improved object, referred to herein as a “peculiar object”, which among other things, facilitates the implementation of a defined transition between object types is described. A peculiar object includes a programming construct referred to herein as a selector, which maps a set of object behaviors to a set of values for a special type of attribute, referred to herein as a “peculiar attribute.” As such, as the value of a peculiar attribute changes, so too does the type or state of the peculiar object. With each transition of the object from one type or state to another, the available behaviors dynamically change.

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 include a method comprising loading a software class containing class information for a lock state. The method includes allocating an instance of a software object derived from the software class, wherein the allocating includes allocating of a lock word as part of the instance of the software object. The lock word defines whether the object is locked by a thread of multiple threads. The method includes observing activity relative to the instance of the software object. The method also includes, responsive to observing the activity relative to the instance of the software object that indicates that the lock state of the instance of the object is non-locking, removing the lock word from the instance of the object.

Abstract: The invention relates to a system for writing a simulation program for simulating an automation installation.

Abstract: A method, computer program product, and system for non-blocking dynamic update of statically-typed class-based object-oriented software executing as byte-code on a virtual machine within an actively running computer system is provided. A set of objects instantiated from an existing module or multiple modules (identifiable collections of application resources and class definitions in the form of byte-code representations) is ready for execution on a virtual machine in an actively running computer system. New versions of one or more modules corresponding to those already loaded into the actively running virtual machine are dynamically loaded into the virtual machine for the purpose of updating the running software. The class definitions within the loaded modules are prepared for dynamic update by inserting byte-code that enables; transparent state transfer and shared object identity between objects of a former version and the new version of a class.

Abstract: Providing for generation of a task oriented data structure that can correlate natural language descriptions of computer related tasks to application level commands and functions is described herein. By way of example, a system can include an activity translation component that can receive a natural language description of an application level task. Furthermore, the system can include a language modeling component that can generate the data structure based on an association between the description of the task and at least one application level command utilized in executing the computer related task. Once generated, the data structure can be utilized to automate computer related tasks by input of a human centric description of those tasks. According to further embodiments, machine learning can be employed to train classifiers and heuristic models to optimize task/description relationships and/or tailor such relationships to the needs of particular users.

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: The claimed subject matter provides a system and/or method that facilitates creating a portion of an industrial process. An interface component can receive a first portion of data associated with a first programming language and a second portion of data associated with a second programming language, wherein the first programming language is independent and disparate of the second programming language. An editor component can create at least one of a portion of an industrial process or a portion of a mixed language object by enabling the combination of the first portion of data and the second portion of data independent of the respective programming languages.

Abstract: Various embodiments of systems and methods for a layering concept for a repository of a user interface framework for Web applications are described herein. The content of a repository provided by different parties (e.g., vendor, partner, customer, user, etc.) is separated. The separation is achieved by assigning solutions to the parties that store content in the repository. Simplified access to the repository is achieved by layering the solutions in a stack and implementing a layer strategy for the layers and their order of access.

Abstract: A computer implemented method, system, and/or computer program product modifies a master template for an executable document. A version architecture comprises a master template for a master document, a new variation document that describes what changes are to be made to the master template for a specific context, and a resulting modified template based on the master template and rule-based instructions found in the new variation document. A processor defines an executable master document from the master template that, when executed, produces a final product. Specific rules set out conditions for modifying the master template for the specific context. These specific rules are used to define a new variation document, which is applied against the master template to generate a context-specific modified template. The context-specific modified template is then used to generate a context-specific executable document that, when executed, generates a final context-specific product.

Abstract: A system for generating and deploying rules in a business rule management system (BRMS) is described. An example system includes a communications module and a translator. The communications module may be configured to receive an input. The input may specify a rule expressed in a custom syntax. The translator may be configured to translate the rule expressed in the custom syntax into a translated rule. The translated rule may be in a form of a source code suitable for being compiled into an executable module.

Abstract: A software development method and system having a suite of graphical customization tools that enables developers to rapidly configure all aspects of the underlying application software, including the look-and-feel, behavior, and workflow. This is accomplished without modifying application source code, base objects, or SQL. The sophisticated repository management capabilities of the method and system of our invention allows teams of developers to work efficiently on configuring applications. The application upgrader provides an automated process to upgrade the customizations to future product releases thus protecting the investment in customization. The ease, comprehensiveness, scalability, and upgradeability of the customization process help reduce the total lifecycle cost of customizing enterprise applications.

Abstract: One or more embodiments of the invention enable a system and method for ordering tasks with complex interrelationships. The present invention as described herein may be used to produce a linear ordering of tasks with complex interrelationships including dependencies and constraints. In one or more embodiments optional tasks may be permitted such that a given task may or may not be added to the execution queue depending on the scheduling of earlier tasks following evaluation of their dependencies—that is, the system of the invention supports the management of optional tasks in a task ordering operation where some or all of tasks have complex interdependencies.

Abstract: Methods for runtime control of hierarchical objects are provided. Certain embodiments provide kinematics procedures in a media content, runtime environment. Making these procedures available in the runtime environment allows the variables of the kinematics procedures to be specified at runtime, for example by the end user or by a runtime-executed script. One exemplary method comprises receiving a hierarchical object for a piece of media in a media content authoring environment and providing the piece of media to one or more runtime environments. The piece of media provided to the runtime environments comprises both object information about the hierarchical object and kinematics procedural information for performing kinematics on the hierarchical object, such as procedural classes for performing inverse kinematics procedures based on runtime-provided end-effector and target point variables.

Abstract: A method for facilitating the processing of markup language documents, e.g., XML documents, uses a code generator that creates programs configured to read dynamic XML documents at run time, avoiding many of the complexities arising from the use of conventional “XML Parse” statements. In one embodiment, this process involves (1) creating a template document using the markup language, wherein the template document includes a set of tags associated with the markup language documents; (2) parsing the template document to determine a data structure corresponding to the tags in the template document; and (3) generating an application program in the programming language (e.g., COBOL), wherein the application program includes a definition of the data structure, and is configured to read, during run-time, the markup language document and generate a corresponding set of data elements corresponding to the data structure.

Abstract: A system to facilitate a service oriented email client application. The system includes a service registry, a service address book coupled to an email client, and an email composer coupled to the service address book. The service registry includes service information. The service information describes how to invoke a web service. The service address book includes a web service entry linked to the service information for the web service in the service registry. The email composer generates a user input form with a custom input field corresponding to the service information for the web service.

Abstract: Architectural design intent for software is represented in some type of concrete form. A set of computable rules are inferred from the representation of the architectural design intent. The rules are applied to the codebase at various points in the development process including but not limited to when source code is checked into a project or when a build is run, or when a test run is performed. If the codebase being developed is not consistent with the architectural intent of the designer as captured, feedback concerning non-compliance is provided.

Abstract: Methods, systems, and apparatus, including computer program products, for implementing a software architecture design for a software application implementing self-service procurement used to procure goods and services “ad hoc” by requests from within an organization. The application is structured as multiple process components interacting with each other through service interfaces, and multiple service interface operations, each being implemented for a respective process component. The process components include an Accounting process component, an Internal Request Processing process component, a Purchase Request Processing process component, a Purchase Order Processing process component, a Goods and Service Acknowledgement process component, a Supplier Invoice Processing process component, a Payment Processing process component, an RFQ Processing process component, and a Due Item Processing process component.

Abstract: Methods and arrangements for employing telephonic voice commands in programming. A voice application is accessed and a program template is customized via selecting components from at least one palette. A program is created from the customized program template, and the created program is deployed and executed.

Abstract: A conflict resolution system allows an end user to export customizations to an application program so that the customizations can be imported by another end user. The conflict resolution system may export a customization by outputting metadata describing the customization. When the customization is a custom property, the metadata may include the name of the entity with which the property is associated, the name of the property, the type of the property, a globally unique identifier for the property, the location on the user interface for the input field for the custom property, and so on. End users may want to share not only their customizations but also the underlying data associated with a customization. When a conflict occurs during import of a customization alone without the data, then the conflict resolution system resolves the conflict in favor of the imported property.

Abstract: Applications can be localized by a localization expert to allow them to be used by a broader customer base. The localization can be conducted by a localization expert who is provided with a resource file containing localizable components. The resource file can be generated by providing a developer with one or more text strings based on the development code of the application and receiving the localizable components which are selected from with the text strings based on the development code.

Abstract: The apparatus of the present invention includes a block diagram dividing unit that divides a block diagram into a plurality of pieces at a branch point, connects a branch point block element to one end of a data line which has been connected to the branch point at each divided piece and thereby generates a plurality of block diagram pieces, a program instruction generator that generates program instructions for performing processing on each block diagram piece, an execution sequence determining unit that determines an execution sequence of generated program instructions, a structural information generator that generates structural information of each of the block diagram pieces and a program generator that arranges the program instructions according to the execution sequence, writes structural information of each block diagram piece into a comment line of each of the program instructions corresponding to each of the block diagram pieces and thereby generates a program.

Abstract: A method for generating boilerplate code is provided. The method may include scanning an initial source code file for an annotation identifying metadata of an element, scanning a generator module for instructions for processing the metadata of the element, and scanning the generator module for a template module that includes an indication of a location for inserting the processed metadata of the element in an output file. The method may further include processing the metadata of the element of the generator module according to the instructions, and inserting the processed metadata of the element at the indicated location in the output file.

Abstract: An object-oriented management device for ASN.1 message is provided, which includes: an ASN.1 bottom supporting module for compiling the ASN.1 message into programming language example code; a common manipulation module for processing the message to support the message applications; a message plug-in for creating the message corpus plug-in from the code generated by the common manipulation module, with the class description table being the plug-in interface. The present invention solves the problem that the message structure example should be re-established after the message is persistently saved, overcomes the disadvantage that the data type of the bit stream must be known in advance for decoding, decreases the difficulty of message construction, and significantly lessens the workload of the message development and maintenance.

Abstract: The disclosure describes a method for programming applications for embedded systems such as sensor nodes. In an embodiment, this comprises writing embedded system applications in a high-level language such as C# or Java using a software development framework which includes a set of tools and class libraries. The class libraries contain pre-written code to carry out tasks which may be required of an embedded system. The class libraries may be extended following identification of a need for a particular function in an embedded system. Developed applications may be subsequently stored on the embedded system but executed on a gateway computing device which interacts with the embedded system. This means that the application(s) can be executed without requiring the presence of a virtual execution system located on the embedded system while allowing a high-level programming model for application programmers.

Abstract: A method of semantic translation of a class of diagrams to input/output-extended finite automata is provided. The method includes receiving a data representation of a diagram, said diagram comprising a plurality of blocks and said diagram being associated with a graphical modeling environment which defines semantics for executing the diagram, and processing, using a computing device, the data representation of the diagram to translate the diagram to an input/output-extended finite automata model.

Abstract: An end-to-end approach is provided for developing and maintaining network device management applications. The approach includes an XML-based development environment for network device management applications that uses Management Data API (MDA) schemas that define a hierarchical data model for components supported by a network device. The XML-based development environment also uses XML schemas to define a common XML-based interface used by management applications to access management data maintained on the network device. The approach provides programmatic access to network device management data and management data schema with an XML-based data model and interface that is consistent across all network device components. The approach includes mechanisms for automatically generating XML requests that conform to a hierarchical data model from requests that conform to a table-based data model.

Abstract: A method, system, and computer program product are disclosed for creating an OWL ontology from a Java source code, wherein the Java source code includes a plurality of Java classes. Each of these Java classes includes one or more Java members and one or more Java objects. The Java objects are used to instantiate each of the Java classes. An OWL class is created for each of the Java classes, and an OWL concept is created for each of the Java members. Further, an OWL instance is created for each of the Java objects. Each of the OWL classes, the OWL concepts, and the OWL instances are assigned data type properties and object properties. Subsequently, each of the OWL classes and relations between them, each of the OWL concepts, and each of the OWL instances are included to form the OWL ontology.

Abstract: A computer language translator that translates all or any portion thereof of source code in an original computer language to source code in a target computer language, which may then be translated back to the original language while still maintaining concept, syntax, form of expression, and formatting of the original source code.

Abstract: A method for using a program to convert a schema to a software data structure includes automatically converting the schema to the software data structure, merging shadow software functionality with the automatically converted software data structure to form a merged software, and executing the merged software.

Abstract: A method, system and computer program product for optimizing an object-oriented program, which comprises identifying synthetic accessor methods added to the program during a compilation to allow access to the members of the inner classes and replacing the synthetic accessor methods with direct accesses to the members of the inner classes.

Abstract: A method and system are disclosed for building complex real-time software that scales well to a large number of processors or CPU cores. The software design and implementation method are based on a combination of object composition (hierarchical assembly) and desynchronizable inter-object interactions.

Abstract: A method for use in replaying actions performed by a user of a software application. An input signal indicating an action performed by the user is received from a user input interface. Computer-executable instructions corresponding to the input signal are executed by a processor. An input event associated with the human-readable statements is stored in a memory device. Application object code corresponding to the human-readable statements may later be executed to replay the input event. In addition, an application state representing one or more variables of the software application may be stored.

Abstract: A business object is generated based on a discovered web service having an associated Web Service Description Language (WSDL) file. The business object includes at least one data type and the at least one interface operation of the WSDL file. The business object is configured to expose web service functionality of the web service in an integrated manner within a business object based application environment. Generating the business object includes converting the at least one data type to a format consistent with the business object based application environment, creating at least one business object node of the business object that corresponds to each interface operation of the WSDL file, the at least one business object node being based on the at least one message, and creating a node action for the at least one business object node, the node action corresponding to the at least one interface operation.

Abstract: A computer implemented rule for verifying consistency in design documents is modeled as a set of associations among deliverable components, and a descriptive text explaining the specification is generated in combination with a text template.

Abstract: A method and apparatus for producer graph oriented programming and execution. According to one aspect of the invention, a runtime is provided that interprets producer dependency declarations for methods. The producer dependency declarations identify at run time a set of zero or more producers, where a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance. The runtime automatically generates and executes, responsive to receiving a designation of a producer of interest whose method has a producer dependency declaration, a producer graph. The producer graph initially includes the producer of interest and is generated, from the producer of interest to source producers, through instantiation of producers based on the producer dependency declarations of the methods of the producers already in the producer graph. The runtime sequences the execution of the producers in the producer graph as indicated by the producer graph.

Abstract: Computer-based methods and systems for generating script-based code, based on a model, are described. Consistent with an embodiment of the invention, a software development application includes a code generator module that receives a model. The code generator module processes the model to generate script-based code. Specifically, the script-based code includes a value object class for each model entity defined in the model, and a service wrapper object class for each service element defined in the model. The value object classes support both basic and advanced data modeling capabilities and corresponding data operations. The service wrapper object classes provide a remote service capability, enabling the client application to communicate with remote services implemented on an application server.

Abstract: An extension node can be defined in a second layer of a software architecture for a first business object existing in a first layer and originally having an association with a second business object that is also in the first layer. The extension node can be defined to have an association with the second business object existing in a second layer of the software architecture. The association of the second business object can be altered from the first business object to the extension node so that at run time, metadata defining one or more nodes of the first business object and the extension node can be read from a metadata repository and a run time version of the first business object can be constructed at run time in a run time business object load based on the metadata.