| Entries |
| Document | Title | Date |
|---|
| 20080201691 | VERSION RESILIENCY FOR A HOST APPLICATION AND CUSTOM CODE - A method and architecture for increasing version resiliency between a host application that is unmanaged code and custom code that is managed code is provided. A host application exposes an application-level object and a document-level object. A custom code runtime provides a wrapper for the document-level object within the application domain of the custom code runtime. The custom code runtime also provides a mechanism within the application domain of the custom code runtime for providing to custom code a reference to the application-level object directly, rather than through a wrapper. Custom code can then access functionality of the application-level object directly using the reference without having to use a wrapper provided by the custom code runtime. | 08-21-2008 |
| 20080209393 | System and method to automatically detect incompatible licensing models - A system and method for inserting a marker in an object file, the marker indicating that at least a portion of the object file is subject to a first license agreement, determining if the first license agreement of the object file and a second license agreement to which one of the object file and a further object file to which the object file is linked are incompatible and when the first license agreement and the second license agreement are incompatible, displaying an error message to a user. | 08-28-2008 |
| 20080235658 | CODE GENERATION FOR REAL-TIME EVENT PROCESSING - A method for information processing includes determining respective execution times for a plurality of operations on a selected computing platform. When a definition of a rule is received, including a complex event and an action to be performed upon occurrence of the complex event, software code is automatically generated to implement the rule on the selected computing platform by invoking a sequence of the operations responsively to the occurrence of the complex event. A worst-case estimate of a duration of execution of the software code is computed, based on the respective execution times of the operations in the sequence. When the worst-case estimate is no greater than a predetermined limit, the software code is run on the selected computing platform so as to cause the action to be performed when the rule is satisfied. | 09-25-2008 |
| 20080244510 | VISUAL CREATION OF OBJECT/RELATIONAL CONSTRUCTS - Visual controls such as drag and drop are utilized to create object-oriented constructs from corresponding relational constructs, for instance. Similarly, an object-relational map can be generated between the relational constructs and the created object-oriented constructs to facilitate interaction across disparate programmatic models. | 10-02-2008 |
| 20080270979 | METHODS AND SYSTEMS FOR USING TYPE MODELS TO GENERATE AN IMPLEMENTATION OF A TYPE - A method for using type analysis to generate an implementation of a type includes the step of identifying a request to generate a first implementation of a type. A type model associated with the type is received. A second implementation of the type model is identified as suitable for a high-performance implementation. The second implementation is generated on a target processor. The second implementation is represented as the first implementation. | 10-30-2008 |
| 20080282224 | Type and property definition support for software - Aspects of the subject matter described herein relate to type and property definition support for software. In aspects, new types can be added to an application model after the software has been created without changing the software. After software is created and embodied in computer code, a new type definition may be received by a user type service. The user type service may then place the new type definition in a data store in which other types native to the software are located. The software may then use the new type definitions and properties associated therewith in queries and in user interfaces provided by the software. | 11-13-2008 |
| 20080307385 | Enhanced Widget Composition Platform - An enhanced widget composition platform, in which code is automatically generated based on receiving a selection of at least a first service and a widget engine via the web-based widget composition platform, the code, when invoked by the selected widget engine, implementing a widget that is operable to communicate with the first service. | 12-11-2008 |
| 20080313607 | UNIFIED INPUT STACK - A unified input stack is disclosed herein. The unified input stack defines a standard mechanism for input data promotion, centralizing the mechanism so that consumers of input data can retrieve the data from a known location in an ideal form. The unified input stack receives input data from an input device and stores the input data in a data object corresponding to the input data. Promoted data corresponding to the input data may then be received. The promoted data may include additional information abstracted from the input data. The promoted data may then be stored in the data object together with the input data. The data object may then be provided to one or more consumers. | 12-18-2008 |
| 20080320440 | FULLY CAPTURING OUTER VARIABLES AS DATA OBJECTS - Providing for read/write access to captured free variables expressed as environment data objects is disclosed herein. By way of example, free variables can be rewritten as a field of a private class, and accessed via an instance of the private class captured within the environment data object. In such a manner, no need of a placeholder or proxy function is required to access the free variable. Consequently, the subject innovation provides a simplified method for capturing free variables within expression trees and providing read/write access to such variables. | 12-25-2008 |
| 20080320441 | EXTENSIBLE RAPID APPLICATION DEVELOPMENT FOR DISPARATE DATA SOURCES - Embodiments of the invention provide an IDE tool that provides rapid application development features for a variety of disparate data sources. Further, developers may customize and extend the rapid application development features to suit their development needs in a particular case. In a particular embodiment, the rapid application development template may be configured to generate a set of configuration files localized used to deploy a “lightweight” application, such as a web-service, to a particular application server. | 12-25-2008 |
| 20090044172 | Generation Of A Program Code In A Load Format And Provision Of An Executable Program Code - In a method for generating program code in a load format for a portable data carrier, a pseudo library is used, which differs from the library located on the data carrier in such a way that at least some of the internal workings of the library located on the data carrier are absent or hidden or masked in the pseudo library. In a method for providing executable program code in the portable data carrier, the program code in load format is linked relative to the library located on the data carrier. A device and a computer program product have corresponding features. The invention provides secure, privacy-safeguarding technology, which allows the generation of program code in a load format for a portable data carrier and the provision of executable program code in the portable data carrier. | 02-12-2009 |
| 20090049423 | JAVASCRIPTTM PROGRAMMING EXTENSION - A JavaScript™ programming extension is provided. An example JavaScript™ programming extension comprises a code generator and a JavaScript™ reference converter. The code generator may be configured to access an existing JavaScript™ file, validate JavaScript™ definitions in the existing JavaScript™ file, and generate a Java™ representation of the existing JavaScript™ file. The JavaScript™ reference converter may be configured to generate a validated JavaScript™ file corresponding to the existing JavaScript™ file. | 02-19-2009 |
| 20090083701 | MULTIPLE SCHEDULERS - A software platform on a computer readable medium, includes a first unit for input representing a process, a second unit receiving the input from the first unit and converting the input into a neutral format process model, a first memory storing object information from the second unit, and a third unit being replaceable and receiving the neutral format process model information and converting into a language for processing in a runtime engine. | 03-26-2009 |
| 20090100408 | System and Method for Supporting Data Driving a Software Process Using Objects of Arbitrary Data Types - The present invention provides a method for supporting data driving a software process. The method comprises receiving, from a user, input of a class of an object of a non-primitive data type; and providing to the user a description of the collection of attributes necessary to construct an instance of the object, based only on the class of the object. The step of receiving the class of the object is free of receiving a pre-existing instance of the data type. In further related embodiments, the method further comprises receiving, in a single user step, user input of defining attribute data necessary to create the instance of the object and set it into a desired state; and creating and initializing the instance of the object using the defining attribute data; wherein the defining attribute data does not include a pre-existing instance of the data type. | 04-16-2009 |
| 20090113385 | SOA SOFTWARE COMPONENTS THAT ENDURE FROM PROTOTYPING TO PRODUCTION - The disclosed invention presents a multi-phased approach for developing a service oriented architecture (SOA) solution using front end SOA components that endure throughout the SOA development lifecycle. The approach can determine interface requirements between a set of services to be implemented in a SOA solution and SOA front end. The SOA front end can conform to the determined interface requirements. The SOA front end can also be interactively utilized early within and can be applicable to all phases of a SOA lifecycle, which includes design, development, and implementation phases. The SOA front end can be combined with a service emulator to form an interactive prototype of the SOA solution. The SOA front end can also be combined with a set of SOA back end components to form the SOA solution. | 04-30-2009 |
| 20090113386 | OBJECT CODE GENERATION FOR INCREASED DELTA PERFORMANCE - Disclosed is a method of generating updated object code of a computer program, the updated object code being suitable for the generation of an updated memory image to be loaded into a storage medium having stored thereon a current memory image corresponding to a current version of a computer program. The method comprises receiving at least one updated input code module from which the updated object code is to be generated; processing at least the updated input code module to generate at least one updated object code module adapted to be linked by a linker component as to generate the updated memory image; performing at least one optimisation process to reduce differences between said updated object code module and a corresponding one of a number of current object code modules, the number of current object code modules corresponding to the current version of said computer program. | 04-30-2009 |
| 20090125879 | Apparatus, Method and System for Building Software by Composition - The present invention is related to the field of real-time software, and, more specifically, to an apparatus, method and system for building complex high-performance software by composition. | 05-14-2009 |
| 20090132996 | Apparatus for control systems with objects that are associated with live data - Methods and apparatus for configuring process, environmental, industrial and other control systems generate and/or utilize models representing configurations of control systems and/or the systems controlled by them. Records of changes to the models or the configurations represented by them are maintained, thereby, for example, providing bases for determining current states, prior states and histories of changes. Objects in the model have characteristics, such as an object type characteristic and an area characteristic. Users can have corresponding permissions. A security mechanism apparatus controls access by users to the objects. Composite objects are defined by definition objects and are displayed in encapsulated or expanded formats. Objects can include an edit control type identifier that determines how they are presented for editing. Functionality responds to user commands by transferring characteristics of a first object depicted by the graphical user interface to a second object. Configuration-time formulas contained objects are evaluated to constants prior to downloading to the control system. | 05-21-2009 |
| 20090138847 | Optimized code generation by eliminating unused virtual function - The present invention relates to a method for reducing the object code size of an application that requires run-time dispatching of object oriented methods. The method comprises scanning an object file corresponding to the application for references to object oriented methods in a dispatch table that performs run-time object oriented method binding. The highest inheritance level associated with an object oriented method is found. All references to object oriented methods above the highest inherence level are designated as unused. All references to object oriented methods below the highest inherence level are designate as used. All references to object oriented methods that are designated as unused are deleted from the dispatch table. | 05-28-2009 |
| 20090164972 | SYSTEM AND METHOD FOR GENERATING RUNTIME METADATA FOR USE IN THE DEVELOPMENT OF MOBILE DEVICE APPLICATIONS - A system and method for generating runtime metadata for use in the development of mobile device applications. A metadata file, such as an XML file that is used to capture the metadata for a database associated with a mobile device application, is used to generate initialization code. This initialization code, when executed, creates runtime metadata for the application database in terms of a first object (e.g. classID object) through which metadata associated with the application database is accessible and at least one second object (e.g. propertyID object) through which metadata associated with a property of a data record of the application database is accessible. | 06-25-2009 |
| 20090178024 | METHOD, COMPUTER PROGRAM PRODUCT, AND SYSTEM FOR MERGING MULTIPLE SAME CLASS INSTANCE STATES - A method, computer program product, and system for enabling the merging of a plurality of instance variables into a new composite same-class instance having the same instance variables with values determined by a user. Same-class instances are arranged in tabular format and are provided with selection buttons to allow the user to make selections of the desired instance variable values. | 07-09-2009 |
| 20090249289 | DETECTING MEMORY ERRORS USING WRITE INTEGRITY TESTING - Methods of detecting memory errors using write integrity testing are described. In an embodiment, additional analysis is performed when a program is compiled. This analysis identifies a set of objects which can be written by each instruction in the program. Additional code is then inserted into the program so that, at runtime, the program checks before performing a write instruction that the particular object being written is one of the set of objects that it is allowed to write. The inserted code causes an exception to be raised if this check fails and allows the write to proceed if the check is successful. In a further embodiment, code may also be inserted to perform checks before indirect control-flow transfer instructions, to ensure that those instructions cannot transfer control to locations different from those intended. | 10-01-2009 |
| 20090259988 | USING A MENU SLIDESHOW FRAMEWORK FOR GENERATING A CUSTOM MENU-DRIVEN SLIDESHOW CONTAINING DEFINABLE CONTENT - A computer program product that includes a project object. The project object can be configured for linearly organizing a series of custom self-contained content. The project object can be a compliable object that includes at least one menu framework object and a set of project data objects. The menu framework object can define a menu. The menu framework object conforms to a standardized menu slideshow framework. The standardized menu slideshow framework can be a reusable templated framework. Each of the project data objects can include a self-contained content object. Each self-contained content object can be programmatically linked to the menu framework object without modifying source code of the self-contained content object. The menu framework object can define a linear ordering of the set of project data objects. | 10-15-2009 |
| 20100083220 | MULTI LANGUAGE EDITOR - 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. | 04-01-2010 |
| 20100083221 | SYSTEM AND METHOD FOR AUTOMATED RE-ARCHITECTUREING OF LEGACY SYSTEMS USING OBJECT ORIENTED LANGUAGE - 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. | 04-01-2010 |
| 20100088671 | PROJECT SCOPES FOR CONFIGURATION BASED COMPUTER APPLICATION PROJECTS - Methods, techniques, and systems for providing project scopes as super-ordinate instances of computer applications projects are provided. Example embodiments provide a method wherein the computer applications are developed based on configuration files of a domain specific language pertaining to calculation tasks. In one embodiment, a “Scope of Resources” class is provided at design phase time. The class defines instances of resources that can be assigned in specific projects. Each project is associated with at least one scope. A project scope is automatically generated when a project is created. The association of resources to scopes and projects is performed during execution of the configured application. In addition to providing pre-configured values and attributes for projects, a scope also provides an aggregation level that is higher than the project level. Accordingly, aggregation analysis can be performed on elements and resources of several projects in their aggregation or taking into account eventual interdependencies. | 04-08-2010 |
| 20100095270 | METHOD AND SYSTEM TO AUTOMATICALLY REGENERATE SOFTWARE CODE - According to a second aspect there is provided a method and system to automatically regenerate software for an object to relational mapping system. The system automatically regenerates a first set of classes. For each class, the system reads class information; reads meta-data based on the class information; and automatically regenerates the class based on the meta-data without overwriting associated custom code. The first set of classes includes base code that is associated with the custom code. The first set of classes and the base code are utilized by the object to relational mapping system to enable access todata that is persistently stored in a database. | 04-15-2010 |
| 20100131923 | Method for Implementing a Medical Informatics System Based on a Computer Executable Health Narrative Coding System - The present invention provides a method for implementing a medical informatics system. The method comprises the step of creating one or more named medical objects having attributes and behaviours, each object being implemented as an object in an object oriented programming paradigm, a function in a functional programming paradigm or an equivalent entity in a hybrid functional/object oriented programming paradigm, wherein the or each medical object name is derived from an algorithmic transformation of a description key assigned to a corresponding medical concept in a medical coding or classification system into an explicit health code, the named medical object having the attributes and behaviours of the corresponding medical concept, the composition of explicit health codes and medical objects derived therefrom being suitable for computer representation of medical narratives. | 05-27-2010 |
| 20100199262 | System For Identifying Attributes And Events With Immutable Sequential Numbers - A method of defining attributes and events in an object oriented software system. The attributes and events are defined by the class as hierarchically unique number fields. They are initialized by a call to a metadata storage object which may be passed attribute or event related metadata for subsequent access by the software system. | 08-05-2010 |
| 20100211928 | Supervisory Process Control And Manufacturing Information System Application Having An Extensible Component Model - A template-based supervisory process control and manufacturing information application development facility is disclosed that includes a number of time-saving application development tools that significantly enhance design productivity and allow re-using of previously developed application building blocks. The development facility includes an application object template library that stores a set of previously defined application object templates. The template library is accessed by developers through a configuration utility that facilitates specifying instances of the set of previously defined application object templates to be included in an application. Thereafter, application objects are instantiated from the selected ones of the set of previously defined application object templates in a build of the specified application. | 08-19-2010 |
| 20100223596 | DATA PROCESSING DEVICE AND METHOD - Based on a constriction condition of a parallel operation device which has been previously registered with data, a data processing device extracts a loop structure from a single-layer state transition graph structure of an object code input thereto, and converts the state transition graph containing a loop structure into a state transition on another layer, which is then output as a new object code. | 09-02-2010 |
| 20100281462 | SYSTEMS AND METHODS FOR GENERATING SOURCE CODE FOR WORKFLOW PLATFORM - Various embodiments of the present invention provide systems and methods for enabling design, generation, and execution of real-time workflows. Such embodiments provide a graphical designer including a plurality of shapes representing the various objects of a workflow that are used to model the workflow. In addition, various embodiments of the graphical designer provide shapes to model aspects of the workflow not found in previous graphical designers. Various embodiments also provide a code generator that converts the representation of the workflow into executable code for multiple target languages. Various embodiments also provide a workflow engine based on a Petri net model responsible for executing the workflow and for delegating tasks to be performed for the workflow to an operating system. In various embodiments, the workflow engine further includes a platform abstraction layer that provides a transition layer from the Petri net language to the operating system language. | 11-04-2010 |
| 20100287531 | System and Method for Generating Web Sites in an Arbitrary Object Framework - A method and system for generating a computer application is disclosed. The computer application is generated on a host system in an arbitrary object framework that separates a content of said computer application, a form of said computer application and a functionality of said computer application. Arbitrary objects are created with corresponding arbitrary names of various object types for generating said content of said computer application, said form of said computer application, and said functionality of said computer application. The arbitrary objects are managed in an object library. The arbitrary objects are deployed from said object library into a design framework to create said computer application. | 11-11-2010 |
| 20100293523 | Development environment configured to generate application source code from database objects - 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. | 11-18-2010 |
| 20110004864 | Method of Dynamically Linking Objects Operated on by a Computational System - In a method for presenting to a user information operated on by a computational software application, a relationship between states of a user interface mechanism located on a workspace associated with the computational software application and an underlying object operated on by the computational software application may be determined. The relationship may be defined at least in part by configuration data capable of being interpreted by the computational software application. A change in a value of the underlying object may be detected, and a current state of the user interface mechanism may be changed based on the detected change in the value of the underlying object and according to the relationship. Additionally, a change in the current state of the user interface mechanism caused by a user may be detected, and the current value of the underlying object may be changed based on the detected change in the current state of the user interface mechanism and according to the relationship. | 01-06-2011 |
| 20110010689 | System for Writing a Simulation Program - The invention relates to a system for writing a simulation program for simulating an automation installation. To facilitate the writing of a simulation program for a complex automation installation, the system comprises —means for defining a respective resource object ( | 01-13-2011 |
| 20110023014 | METHOD AND APPARATUS FOR MODIFYING AN EXECUTABLE APPLICATION USING IN-MEMORY OBJECT REPRESENTATION - A computer system is used to create an application. An executable application is converted into an in-memory object representation. The in-memory object representation may be annotated with human-readable labels. The in-memory object representation and human readable labels may be stored in a storage device. At least one attribute of the in-memory object representation is selected for modification. At least one modification is performed on the in-memory object representation of the application. The modified representation is used to create an executable application. | 01-27-2011 |
| 20110035725 | SYSTEM AND METHOD FOR AUTOMATED RE-ARCHITECTUREING OF LEGACY SYSTEMS USING OBJECT ORIENTED LANGUAGE - 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. | 02-10-2011 |
| 20110055808 | GENERATING OBJECT CODE THAT USES CALCULATED CONTENTS FOR A VARIABLE DETERMINED FROM A PREDICATE - In an embodiment, a predicate condition that compares a predicate variable to a compared value is determined. The predicate condition is in a predicate block that exists on a path to a current block that accesses a current variable. A decision is made whether the current variable and the predicate variable are defined by a sub-clique and whether a member of the sub-clique sets the predicate variable to a predicate value that causes control flow to take the path from the predicate block to the current block. Upon a determination that the current variable and the predicate variable are defined by the sub-clique and the member of the sub-clique sets the predicate variable to the predicate value that causes control flow to take the path from the predicate block to the current block, then contents for the current variable are calculated and first object code is generated, which loads the contents. | 03-03-2011 |
| 20110067002 | Distributed Collaborative Environment Definition System and Method - Disclosed is a system and method for generating a reusable virtual environment item to be integrated into a visual computer simulation wherein the reusable virtual environment item is generated using data gathered from a plurality of developers, wherein the system comprises a centralized knowledge management module, a plurality of distributed workspaces, a content repository, and a content production tool. | 03-17-2011 |
| 20110099533 | Process Control Script Development And Execution Facility Supporting Multiple User-Side Programming Languages - A supervisory process control and manufacturing information application development and execution system is disclosed that supports the execution of application object scripts derived from multiple different scripting languages. In particular, the system includes a script editor interface that enables submission/specification of scripts for application objects. The script editor interface supports multiple distinct user-side script languages (e.g., user-supplied script text). A script translation component that receives the user-side script includes routines for rendering execution-side script (executable by a script engine) from source script rendered by the script editor and written according to any of a set of user-side script languages supported by the script translation component. The translator supports at least a first scripting language and a second scripting language. Finally, an execution portion of the system includes an engine for processing the commands within the translated output execution-side script generated by the script translation component. | 04-28-2011 |
| 20110119652 | GENERATING OBJECT ANNOTATIONS - A computer-implemented method is disclosed for generating Dojo-conforming JavaScript Object Notation (JSON) objects for base objects of an object-oriented programming environment that have been annotated to denote which attribute declarations of the base object correspond to identified Dojo attributes. In a Java class, for example, annotations may be made to indicate which class attributes correspond to the identifier attribute of a Dojo JSON object and based on those annotations a Dojo-conforming JSON object may be generated. | 05-19-2011 |
| 20110126170 | Integrated Development Environment and Methods of Using the Same - A method is provided for generating, in an IDE, a form from which a source code superclass and subclass can be generated. The form is modifiable such that the superclass and subclass integrity is maintained. The method comprises receiving, in an IDE, objects to create a form, wherein the IDE comprises one or more classes. The IDE is utilized to run the form and store the form. The IDE is further utilized to generate and store a superclass comprising one or more of the objects and one or more classes. The superclass is extended with a subclass. The IDE is again utilized to modify the form and generate a new superclass based on the modified form, wherein the integrity between the new superclass and the subclass is maintained. | 05-26-2011 |
| 20110145785 | Automatic Optimization of String Allocations in a Computer Program - Access is obtained to an input object-oriented computer program. In the input object-oriented computer program, semantically equivalent objects are identified, which exist in different memory locations. If at least one of: a number of occurrences for the semantically equivalent objects exceeds a first threshold value, the threshold value being at least two; and a number of equality tests on the semantically equivalent objects exceeds a second threshold value, then a further step includes identifying an application program interface to reduce the semantically equivalent objects to a single object in a single memory location. | 06-16-2011 |
| 20110167406 | METHODS AND SYSTEMS FOR RELATING DATA STRUCTURES AND OBJECT-ORIENTED ELEMENTS FOR DISTRIBUTED COMPUTING - Methods and systems consistent with the present invention provide an improved software development tool that generates code corresponding to a distributed computing component that contains methods of a plurality of types and that displays a graphical representation of the code with a separately delineated display area for each type. The improved software development tool also compiles, deploys, and debugs the distributed computing component with a client software component using methods and systems consistent with the present invention. | 07-07-2011 |
| 20110191751 | DECLARATIVE ATTRIBUTE SECURITY USING CUSTOM PROPERTIES - In various embodiments, application development tools can allow developers to control whether or not an attribute of a view object is displayed by declaratively associating a data security privilege with the attribute. Associating a data security privilege with the attribute can be done by adding a specially named custom property on the view object attribute. Modifications to a base class can provide any necessary support to retrieve the privilege and determine whether a current user is allowed to view the attribute for the current record/row. If the user is authorized to view the attribute for the current record/row, then the attribute value is returned and displayed. Otherwise, redacting information, such as “*****” can be returned and displayed. | 08-04-2011 |
| 20110252400 | ADDING INHERITANCE SUPPORT TO A COMPUTER PROGRAMMING LANGUAGE - Methods, apparatus and computer program products for supporting inheritance in a programming language are provided. The method includes the steps of: 1) receiving a first programming object from a first file; 1) receiving inheritance information about the first programming object, the inheritance information being from second file; 2) analyzing the inheritance information; 3) creating a second programming object based on the first programming object and the inheritance information; 4) sending the second programming object to an editor for editing; 5) receiving a third programming object from the editor, wherein the third programming object was created by editing the second programming object; 6) creating a fourth programming object based on the first or second programming object, the third programming object and the inheritance information; and 7) storing the fourth programming object in a third file. | 10-13-2011 |
| 20110265062 | Paradigm in Multimedia Services Creation Methodology, and New Service Creation and Service Execution Environments - The present invention discloses a new paradigm in Multimedia Services Creation Methodology, and new Service Creation and Service Execution Environments, based on this methodology. A service designer can access the Service Creation Environment via a Web based Graphical User Interface (GUI), to design new service in an automated way. The design process includes creation of the Service Logic Script (SLS), and associated databases that are used for storage of service and subscriber related data. The service developer (user) assembles Language Graphical Objects (LGO) into Service Logic Script. LGOs are part of a new graphical language that has been developed to meet multimedia service creation needs. They represent service control and call control primitive functions that have to be performed, in order to provide a multimedia service to service subscribers. | 10-27-2011 |
| 20110271248 | CONVERTING CONTROLS INTO SOURCE CODE - Aspects of the subject matter described herein relate to converting controls into source code. In aspects, a control is created via a designer. The control may include properties, code, and a visual representation. The control may be represented at least in part via a markup language. At one or more times during or after development of a software project, source code for the control may be generated, transformed, and placed into the project. This may be done, among other reasons, to simplify software development. | 11-03-2011 |
| 20110283256 | METHOD, COMPUTER PROGRAM PRODUCT, AND SYSTEM FOR NON-BLOCKING DYNAMIC UPDATE OF STATICALLY TYPED CLASS-BASED OBJECT-ORIENTED SOFTWARE - Under the present invention, 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. On the event of a software update, the objects instantiated from a former version of an updated class become un-initialized surrogate objects with the potential to redirect to their future corresponding objects. Corresponding objects are created lazily on first access of the declaring class members. Besides lazy redirection of the behavior of objects and classes, non-blocking dynamic update is achieved by lazy migration of the state of former objects and classes while locking on a temporary field access lock. Thus, the algorithm for controlling field access and state migration is completely lock-free both before and after state migration; hence the performance degradation is minimal. Finally, any unreferenced objects are removed from memory. | 11-17-2011 |
| 20110289477 | SYSTEMS AND METHODS FOR AN EXTENSIBLE SOFTWARE PROXY - A system and method for creating a proxy object capable of communication with an external entity, comprising specifying a proxy object definition for the proxy object wherein the proxy object definition defines a first function for communicating with the external entity, specifying at least one implementation class for the proxy object definition, wherein the at least one implementation class does not implement the first function, and wherein the at least one implementation class includes functionality to support one of: proxy object design, software compilation and software execution. | 11-24-2011 |
| 20110321005 | COMPACTION AND DE-ALLOCATION OF PARTIAL OBJECTS THROUGH SCHEDULING A TRANSACTION - Illustrated is a system and method for identifying a current object that is part of a versioned object, the versioned object to include at least one partial object and a base object. The system and method further include marking the at least one partial object as a candidate for compaction. Additionally, the system and method include compacting the at least one partial object, where the at least one partial object is marked, by replacing a characteristic of the base object with a characteristic of the at least one partial object. The system and method includes scheduling a transaction for each thread in a transaction pool so as to de-allocate memory associated with the at least one partial object, the transaction to be executed in a non-preemptable manner. | 12-29-2011 |
| 20120023479 | METHOD AND A COMPUTER PROGRAM PRODUCT FOR AUTOMATICALLY GENERATING A USER INTERFACE FOR AN APPLICATION PROGRAM - A method and a computer program product include the steps of receiving, into a computing machine, a business logic (BL) source code for an application program, the BL source code comprising at least a class, an object and a method or function. Steps transform, in the computing machine, the BL source code into an executable BL. Steps acquire schema information from the BL source code. Steps generate, in the computing machine, a user interface (UI) source code for a form using the schema information for the class. Steps transform, in the computing machine, the UI source code into at least one executable UI. | 01-26-2012 |
| 20120102453 | MULTI-DIMENSIONAL OBJECTS - Architecture that enables a software object to be a multi-dimensional object by associating additional dimensions to the object. The object, in addition to the actual data dimension, is now provided with inherent object dimensions that include, but are not limited to, a localization dimension, security dimension, version dimension, personalization dimension, and attributes dimension, for example. The actual data dimension and one or more inherent object dimensions can be added, changed, or modified in realtime. A mapping component maps object relationships between an in-memory form and a tabular form storable in a database. An application programming interface facilitates interaction with the object, and the actual data dimension, and the one or more inherent object dimensions. | 04-26-2012 |
| 20120110547 | SYSTEM AND METHOD FOR A GENERIC OBJECT ACCESS LAYER - An object access interface is described that effectively decouples a functional layer from a user interface (UI) layer. In the context of pre-existing functional objects that are specifically tailored to a pre-existing UI, a single entry point access-interface may define generic and object-specific functions. The function may be used to collect input routed to the associated function object, compile an input set in a form similar to how the pre-existing UI provided input sets, and process the compiled input and any resulting outputs from the function object. | 05-03-2012 |
| 20120151434 | System And Method For Generating One Or More Plain Text Source Code Files For Any Computer Language Representing Any Graphically Represented Business Process - The present invention is a system to generate plain text source code files involving a language representing a business process that includes a domain specific framework describing the business process with one or more points of view using one or more objects, a meta-model language that combines proprietary tags and computer instructions involving a specific solution domain and a code generator that uses the objects and files written in the meta-model language. The system also utilizes a method for generating plain text source code files involving any computer language representing a business process. | 06-14-2012 |
| 20120159431 | SYSTEM AND METHOD FOR MODULAR BUSINESS APPLICATIONS - A method of providing tailored add-on applications to an underlying foundational software suite that frequently receives updated versions that would otherwise overwrite changes in the foundational software that are required by the tailored add-on. Instead of functional changes to the foundation, the tailored add-on makes a fairly uniform and simple change in the place of each needed change, by inserting a call to an add-in definition object. The add-in definition object then contains code for performing the functionality needed by the add-on application. The add-in definition object is down-ported to all supported versions of the foundational software. The calls of the add-in definition object are integrated into the foundational software in a way which minimizes conflicts, allows for concurrent implementation while maintaining a clear separation between foundational code and modified code, and minimizes ongoing maintenance development of the add-on application's conflicts with the foundational application. | 06-21-2012 |
| 20120174062 | PORTLET TEMPLATE BASED ON A STATE DESIGN PATTERN - A method for designing object-oriented software for implementing portlets, and an associated computer system and computer program product. The portlets are available to a user of the software who clicks on a link of a first page to identify an action object of an Action class and a state object of a State class. The software includes the State class, the Action class, and program code. The State class includes a method for displaying a view of a page. The Action class includes an actionPerformed method for performing an action and a setState method for setting the state object into the session. The program code is adapted to execute: the actionPerformed method of the action object to perform the action; the setState method of the action object to set the state object; and the method of the state object to display a view of a second page. | 07-05-2012 |
| 20120180023 | IMAGE PROCESSING APPARATUS, IMAGE PROCESSING METHOD, AND NON-TRANSITORY COMPUTER-READABLE STORAGE MEDIUM - An image processing apparatus includes plural module creating units, plural wrapper creating units, an extracting unit, a calling unit, and an argument processing unit. The module creating units create processing modules that are obtained by instantiating different types of image processing classes by using functions. The wrapper creating units create wrappers that call the module creating units and that pass arguments specified in a pointer form to the module creating units. The extracting unit extracts, from image processing information, class names of the image processing classes corresponding to the individual processing modules and the arguments unique to the image processing classes. The calling unit converts the extracted class names and calls the wrapper creating units to which the converted class names are given. The argument processing unit stores the extracted arguments in an array, specifies an initial address of the array, and passes the initial address to the created wrappers. | 07-12-2012 |
| 20120192149 | CODE GENERATION FOR REAL-TIME EVENT PROCESSING - A method for information processing includes defining a set of abstract operators for use in implementing computing operations, including iterative operations. Respective execution times are determined for the operations implemented by the abstract operators. Given a definition of a rule, including a complex event and an action to be performed upon occurrence of the complex event, software code to implement the rule is automatically generated by generating concrete instances of the abstract operators so as to invoke a sequence of computing steps that includes iterations of the iterative operations. A worst-case estimate of a duration of execution of the software code is computed based on the respective execution times. | 07-26-2012 |
| 20120227028 | GRAPHICAL PROGRAMMING OBJECT POPULATION USER INTERFACE AUTOGENERATION - Automatically generated user interfaces are provided to aid data population of object instances in graphical programming environments. A selection gesture identifies an instance of an object type. The public fields defined for the instance are automatically determined, and a user interface is automatically generated with the name of each defined field and a currently assigned value for each field that has one. Fields which have no currently assigned value are optionally displayed with a hint. The user interface can be placed in an application under development, such as a sequential workflow application, as a class initializer and/or as an object configurator. When the object to be populated has another object as a field, the fields of that nested object are similarly displayed. Data can be entered into a container object through the user interface without replacing prior value(s) of the container object. | 09-06-2012 |
| 20120297360 | DYNAMIC CODE GENERATION AND MEMORY MANAGEMENT FOR COMPONENT OBJECT MODEL DATA CONSTRUCTS - Dynamic code generation and memory management techniques are provided for component object model (COM) objects with corresponding representations in script code and native code. A browser component can receive script code including the code representing the COM object and a marshaling component is provided that marshals, based on a request for native code representing the COM object, the code representing the COM object to the native code based on a pre-constructed intermediate data structure. The pre-constructed intermediate data structure, such as a virtual table, is pre-constructed based on a dynamic type representation associated with a prototype of the COM object and cached for re-use by the marshaling component. Other embodiments provide finalizer support for memory management of COM objects having script and native world representations including an implementation of a two-phase commit protocol that enables efficient and conservative recycling of objects and associated memory. | 11-22-2012 |
| 20120311531 | OPTIMIZING AN OBJECT-ORIENTED PROGRAM BY TRANSFORMING INVOCATIONS OF SYNTHETIC ACCESSOR METHODS - 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. | 12-06-2012 |
| 20120311532 | IMMUTABLE PROPERTIES IN A CLASS - 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. | 12-06-2012 |
| 20120324421 | APPLICATION CREATION TOOL TOOLKIT - Various embodiments of systems and methods for an application creation tool (ACT) toolkit are described herein. The ACT toolkit includes a set of application creation APIs and an application creation service for invoking the set of application creation API. An ACT is in communication with the application creation service of the ACT toolkit. The ACT sends an application creation request to the application creation service for creating a UI application. The ACT can be customized by re-defining the application creation service of the ACT toolkit and establishing a communication between the re-defined application creation service and the ACT. The re-defined application creation service invokes the set of API to create a customized application object for the UI application. | 12-20-2012 |
| 20130007699 | POPULATION OF DYNAMIC OBJECTS REPRESENTING STATIC NAMESPACE HIERARCHIES - A namespace-based static metadata model is projected into a dynamic programming environment. A dynamic object is created for each static namespace. The host environment populates the dynamic object with a top-level namespace of the static namespace. The dynamic objects are defined such that a request for a member a member of the namespace lazily populates the static metadata into a projected sub-namespace object or a projected type object. | 01-03-2013 |
| 20130055200 | APPLICATION INTERFACE FOR OBJECT BUILD INFORMATION - The formulation of an application object in a memory of a computing system. A system level of the computing system determines that an application object is to be created, but also determines that at least part of the object build information to be used to create the application object is available at an application running on the computing system. The system then interfaces with the application through an interface to cause the application object to be created in the memory using the object build information that is available at the application. As an example, the system level may be parsing a hierarchically structured document that defines various objects of a program. | 02-28-2013 |
| 20130061205 | AUTOMATED GENERATION OF BRIDGING CODE TO AUGMENT A LEGACY APPLICATION USING AN OBJECT-ORIENTED LANGUAGE - A legacy machine-oriented language interface definition of a new module to be implemented within a legacy machine-oriented language application using an object-oriented language is received at a processor. An object-oriented class definition and bridging code that interfaces the object-oriented class definition to the legacy machine-oriented language interface definition is generated by the processor. An updated version of the object-oriented class definition is received that includes object-oriented code that implements functionality of the new module. A new version of the legacy machine-oriented language application is created that includes the new module as a new object accessible using the legacy machine-oriented language interface definition and as implemented by the object-oriented code in the updated version of the object-oriented class definition. | 03-07-2013 |
| 20130086549 | FLOW-OPTIMIZATION SYSTEM AND METHOD FOR CLOUD COMPUTING - A cloud computing interface includes a high-level compiler uses a modified flow language referred-to as “Resilient Optimizing Flow Language” (ROFL) that converts inputs relating to source program and data definitions to generate bytecode objects that can be used by an execution engine to allocate input data to “processes” created by the execution engine based on available resources, so as to evaluate or perform particular tasks on the input data. | 04-04-2013 |
| 20130111435 | REDUCING OBJECT SIZE BY CLASS TYPE ENCODING OF DATA | 05-02-2013 |
| 20130125092 | GENERATING DEPLOYABLE CODE FROM SIMULATION MODELS - A method for generating deployable code from a simulation model includes receiving the simulation model, generating object-oriented programming language components from the simulation model, generating general programming language source code, a general programming language library and a compiled general programming language library from the dynamic simulation model, deploying the object-oriented programming language components and a deployable jar and deploying the compiled general programming language library. | 05-16-2013 |
| 20130125093 | GENERATING OBJECT-ORIENTED PROGRAMMING LANGUAGE CODE FROM A MULTI-DOMAIN DYNAMIC SIMULATION MODEL - A method for generating an object oriented programming language source code from a simulation model includes receiving the simulation model, generating header files from the simulation model, in a general programming language, generating bridge code that aids in generating object-oriented programming language templates that include template maps, generating object-oriented programming language components from the template maps, aggregating the object-oriented programming language components; and generating object-oriented programming language source code and wrappers from aggregating the object-oriented programming language components. | 05-16-2013 |
| 20130227520 | Rapid process integration through visual integration and simple interface programming - In a first aspect, the invention features a method. A method of simplifying object interaction comprises defining objects whose public interface contains only properties; creating structured data objects; locating references to objects in the structured data object; associating said structured data object with at least one thread; locating said references; initializing said objects; accessing said objects; wherein said objects are persist-able; wherein said properties contain values or locators containing a reference to values. | 08-29-2013 |
| 20130263085 | OBJECT PROPERTY - VALUE SPECIFICATION USING POP-UP GRAPHICAL INTERFACES - A method of populating object property values includes receiving an instruction on behalf of a user. The instruction represents an input indicating selection of the object. The method includes presenting, in response to the input, a list of property names and corresponding default values associated with the selected object, and presenting, for each of one or more default values, a user input field. The method includes presenting, for each of the one or more default values, an enumeration of alternative property values when the enumeration is compatible with the corresponding property. The method includes receiving from the user, for zero or more of the property names, an updated property value that is a selection from a value entered in the user input field or the enumeration of alternative property values, and generating code operative to instantiate the object. The updated property values are associated with the properties of the object. | 10-03-2013 |
| 20130275941 | DEFINITION OF OBJECTS IN OBJECT-ORIENTED PROGRAMMING ENVIRONMENTS - In an object-oriented programming environment having a hierarchical object structure an object type is defined by declaring different types of objects and properties associated therewith. A base type is declared. Properties for the base type are declared. A set of aggregated objects comprising individual objects of different types is declared. The set of aggregated objects is to be instantiated in a master object created from the object type. A set of auxiliary objects comprising individual objects of different types and associated with the object type is declared. The individual objects of the set of auxiliary objects are to be instantiated in respective locations in the hierarchical object structure. | 10-17-2013 |
| 20130290927 | DYNAMIC CODE GENERATION TO DYNAMICALLY CREATE AND DEPLOY MESSAGING PROVIDER-SPECIFIC WRAPPERS FOR A RESOURCE ADAPTER - A computer-controlled method can include an application providing a request to a resource adapter and, responsive to receiving the request, the resource adapter instructing a Java Messaging Service (JMS) provider to provide an object. The JMS provider can provide the requested object to the resource adapter. The resource adapter can send to a class loader a request for the class loader to create a class and, responsive thereto, the class loader can create the class and provide it to the resource adapter. The resource adapter can instantiate the class to create a wrapper object, wrap the object based on the wrapper object, and send the wrapped object to the application. | 10-31-2013 |
| 20130332898 | OBJECT EXTENSIONS USING ATTRIBUTES TO DECOUPLE BASE CLASSES FROM DERIVED CLASSES - An object oriented application framework is provided in which base classes are decoupled from derived classes by using attributes. Relationships between derived classes and attributes can be generated, and derive classes can be statically or dynamically instantiated at run time. By decoupling the base class from derived classes using instances of such attributes, a developer does not modify computer program code defining the base class when adding customized extensions to that base class. The framework includes a class factory that uses instances of attributes associated with elements to derive, at run time, extension classes. The attributes can be specified at run time to specify or to alter the run time behavior of the application. This framework also allows the application to conditionally instantiate an element based on its attributes. | 12-12-2013 |
| 20140026114 | LAYERING OF BUSINESS OBJECT MODELS VIA EXTENSION TECHNIQUES - 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. | 01-23-2014 |
| 20140040856 | Apparatus, Method and System for Building Software by Composition - 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. | 02-06-2014 |
| 20140068552 | INFRASTRUCTURE FOR AUTOMATICALLY GENERATING BOILERPLATE CODE USING ANNOTATIONS AND CODE-GENERATORS - 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. | 03-06-2014 |
| 20140143754 | SYSTEM AND METHOD FOR THE STRUCTURING AND INTERPRETATION OF ORGANIC COMPUTER PROGRAMS - 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. Together, these factors provide a programming system wherein normalization occurs over time through the exchange and integration of differences and evolution and diversification through the creation of new differences, thereby introducing a differential form of computer science. | 05-22-2014 |
| 20140237445 | SYSTEM AND METHOD FOR AN OBJECT INSTANCE ACQUIRER - A method, computer program product, and computer system for receiving, at a computing device, an input including an indication of a type of an object for which an instance is required. Code that is declared in a software development application is scanned for the instance. An output is generated including one or more suggestions how to acquire the instance based upon, at least in part, the code that is declared in the software development application. | 08-21-2014 |
| 20140250421 | Systems and Methods for Creating Multi-State Content - Methods and systems for creating multi-state content using state information are disclosed. The state information may specify, for example, that a subcomponent is included in one state and excluded from another state. As another example, the state information may specify that an attribute of the object will have a first value in one state and a different value in another state. Certain embodiments allow a developer to use declarative statements to specify different states for an object. These declarative statements may directly specify the appearance attributes or subcomponents of the object. Certain embodiments allow a developer to specify state-specific appearance attributes and sub-components within the general specification of the object and without having to specify appearance attributes or subcomponents in terms of changes to a base state or any other state. | 09-04-2014 |
| 20140325474 | Annotation-Based Item Description - Example systems and methods that provide annotations of item descriptions are described. In one implementation, a method accesses data associated with an item and identifies multiple attributes associated with the item. The method further generates a Java class associated with the item and annotates the Java class to include the attributes associated with the item. | 10-30-2014 |
| 20140337817 | OBJECT-ORIENTED SYSTEM FOR CREATING AND MANAGING WEBSITES AND THEIR CONTENT - The invention teaches a method for creating and managing a website as an object oriented system, comprising: providing on a system server a plurality of hierarchical classes of objects, each of the classes representing one aspect of the storage, presentation and logic of a website; providing on a web server an interface operable to present representations of objects instantiating the plurality of hierarchical classes and receive commands meant to one of: instantiate a new object, destroy a presented object, and change a property of a presented object; and storing on a database server objects as a traversable tree in accordance with the plurality of hierarchical classes. | 11-13-2014 |
| 20140365997 | OBJECT PROPERTY-VALUE SPECIFICATION USING POP-UP GRAPHICAL INTERFACES - A method of populating object property values includes receiving an instruction on behalf of a user. The instruction represents an input indicating selection of the object. The method includes presenting, in response to the input, a list of property names and corresponding default values associated with the selected object, and presenting, for each of one or more default values, a user input field. The method includes presenting, for each of the one or more default values, an enumeration of alternative property values when the enumeration is compatible with the corresponding property. The method includes receiving from the user, for zero or more of the property names, an updated property value that is a selection from a value entered in the user input field or the enumeration of alternative property values, and generating code operative to instantiate the object. The updated property values are associated with the properties of the object. | 12-11-2014 |
| 20140372973 | SYSTEM AND METHODS FOR GENERATING DATA OBJECTS - Aspects of the present disclosure include systems and methods for generating generic data patterns or structures that may be used to generate data-driven objects for subsequent use in software development. In various aspects, data-driven objects may be defined and subsequently used to design the anticipated behavior of a software application. | 12-18-2014 |
| 20150012909 | AUTOMATED GENERATION OF BRIDGING CODE TO AUGMENT A LEGACY APPLICATION USING AN OBJECT-ORIENTED LANGUAGE - A legacy machine-oriented language interface definition is received of a new module to be implemented, using an object-oriented language, to provide a new feature within a legacy machine-oriented language application that is executable within a legacy application execution platform. An object-oriented class definition and bridging code that interfaces the object-oriented class definition to the legacy machine-oriented language interface definition are generated. An updated version of the object-oriented class definition is received that includes object-oriented code that implements functionality of the new feature within the new module. A new executable version of the legacy machine-oriented language application is built. The new executable version of the legacy machine-oriented language application is executable within the legacy application execution platform, and includes the new module as a new object accessible using the legacy machine-oriented language interface definition with the functionality of the new feature as implemented by the object-oriented code. | 01-08-2015 |
| 20150026658 | Systems, Methods and Media for Dynamic Creation and Update of Activation Context for Component Object Model - Systems, methods and media are provided for dynamically creating/updating an activation context at runtime. One method includes receiving a request to create a component object, the request including a component identification of the requested component. The method also includes accessing a type library associated with each of multiple executable files. The type library includes an identification of each executable file and library content. The method further includes updating a manifest at runtime by enumerating the library content of each executable file and adding to the manifest the identification and the enumerated library content. The method also includes creating an activation context based on the updated manifest and determining using the component identification whether the activation context includes the requested component. The method further includes activating the activation context and creating the requested component object using the activation context, when it is determined that the activation context includes the requested component. | 01-22-2015 |
| 20150067639 | CONCURRENT ACCESSES OF DYNAMICALLY TYPED OBJECT DATA - A method and an apparatus for an enhanced object model to allow concurrent execution for program code generated from dynamic programming languages, such as JavaScript, are described. An index structure may be introduced to an object model representing a dynamically typed object in addition to a type structure and a data payload storing property or field values of the object. Elements of the index structure may point at corresponding property values as an indirection for accessing the object. | 03-05-2015 |
| 20150089470 | RULE-BASED AUTOMATIC CLASS GENERATION FROM A JSON MESSAGE - A method, system, and computer program product for Java development environments. The method commences upon receiving a set of one or more rules to be applied to one or more JSON messages, then generating of one or more Java classes respective to received JSON messages. The received JSON messages can be retrieved from a repository for JSON message files, or the JSON messages can be received by sniffing a message transmitted over a network link. The rules can be applied according to one or more precedence regimes, and applying the precedence regimes over the two or more rules can be considered in a pre-processing step performed before receiving a JSON message or can be considered after receiving a JSON message. | 03-26-2015 |
| 20150095880 | FACILITATING SOFTWARE DEVELOPMENT TOOLS ON MOBILE COMPUTING DEVICES IN AN ON-DEMAND SERVICES ENVIRONMENT - In accordance with embodiments, there are provided mechanisms and methods for facilitating dynamic software development tools on mobile computing devices in an on-demand services environment in a multi-tenant environment according to one embodiment. In one embodiment and by way of example, a method includes initiating an application building tool to generate a new software application for a computing device. The application building tool may be accessible via a user interface at the computing device including a mobile computing device or one or more other computing devices. The method may include providing a software development environment to facilitate user interactions based on the new software application, where each user interaction is associated with one or more objects in an on-demand services environment. | 04-02-2015 |
| 20150095881 | COMPUTATIONAL DESIGN METHOD AND INTERFACE - A method, system, apparatus, computer program product, and computer readable storage medium provide the ability to define an object in a parametric modeling application. Geometric parametric objects are authored and organized into a family definition. Via a user interface, enhanced computational logic is defined. The logic is compiled into the family definition such that the enhanced computational logic is embedded at an object level of the one or more geometric parametric objects. Upon a building information model requiring a regeneration operation, the compiled enhanced computational logic is automatically executed. | 04-02-2015 |
| 20150347092 | System and Method for Generating Web Sites in an Arbitrary Object Framework - A method and system for generating a computer application is disclosed. The computer application is generated on a host system in an arbitrary object framework that separates a content of said computer application, a form of said computer application and a functionality of said computer application. Arbitrary objects are created with corresponding arbitrary names of various object types for generating said content of said computer application, said form of said computer application, and said functionality of said computer application. The arbitrary objects are managed in an object library. The arbitrary objects are deployed from said object library into a design framework to create said computer application. | 12-03-2015 |
| 20160062742 | MODEL-DRIVEN OBJECT COMPOSITION FOR DATA ACCESS USING FUNCTION-EXPRESSIONS - A computer-implemented method for creating an object for data access is provided. The computer-implemented method includes defining a function-expression in source code using an object-oriented programming language. The defined function-expression is exposed in a graphical user interface of a development tool used to create the object. A selection of at least one field among a list of available fields for data access is received. The defined function-expression is included in the list of available fields. An integrated development environment is also provided. | 03-03-2016 |
| 20160077811 | Graphical Development and Deployment of Parallel Floating-Point Math Functionality on a System with Heterogeneous Hardware Components - System and method for configuring a system of heterogeneous hardware components, including at least one: programmable hardware element (PHE), digital signal processor (DSP) core, and programmable communication element (PCE). A program, e.g., a graphical program (GP), which includes floating point math functionality and which is targeted for distributed deployment on the system is created. Respective portions of the program for deployment to respective ones of the hardware components are automatically determined. Program code implementing communication functionality between the at least one PHE and the at least one DSP core and targeted for deployment to the at least one PCE is automatically generated. At least one hardware configuration program (HCP) is generated from the program and the code, including compiling the respective portions of the program and the program code for deployment to respective hardware components. The HCP is deployable to the system for concurrent execution of the program. | 03-17-2016 |
| 20160085521 | State-Specific External Functionality for Software Developers - A system includes a user interface presented to a developer. The developer selects a first function to supplement functionality of a first application with external functionality available from third party applications. A code generation module provides a software object to the developer for incorporation into a first state of the first application. The first state includes a user interface element associated with an entity. User selection of the user interface element initiates preparation of a query wrapper including a combination of the entity's name and a predefined text string corresponding to the first function. The query wrapper is transmitted to a search system and a result set is received and displayed. A first item of the result set includes an access mechanism for a specified state of a target application. User selection of the first item causes the access mechanism to open the target application to the specified state. | 03-24-2016 |
| 20160147508 | METHOD FOR CONNECTING OBJECTS IN A SOFTWARE APPLICATION - A computer-implemented method and a correspondingly adapted computer program product or software application for connecting business objects in a software application (SA), wherein the software application comprises a connector (K), wherein the connector comprises a code identifying an abstract business object class (ABO | 05-26-2016 |
| 20160253155 | APPARATUS AND METHOD FOR METAPROGRAMMING PLATFORM | 09-01-2016 |
| 20160378447 | SELECTING APPLICATION WRAPPER LOGIC COMPONENTS BASED ON FEATURES OF A MOBILE APPLICATION TO BE WRAPPED - Executable code of an application package is decompiled to provide a decompiled application package. Features of the application package are identified based on content of the decompiled application package. A set of wrapper logic components are selected from among a library of wrapper logic components based on the features of the application package. The decompiled application package is disassembled to provide disassembled code. Wrapper program hooks are inserted into the disassembled code to provide modified disassembled code. The modified disassembled code is assembled to provide modified assembled code. The wrapper logic components of the set are combined with the modified assembled code to form a wrapped application package including executable code from the modified assembled code and executable code from the wrapper logic components of the set that intercept calls by the executable code from the modified assembled code. | 12-29-2016 |
| 20180024816 | CODE SNIPPET CONTENT RECOMMENDATION TO DEFINE AN OBJECT LITERAL | 01-25-2018 |
