| Class / Patent application number | Description | Number of patent applications / Date published |
|---|
| 717116000 | Object oriented | 72 |
| 20080222602 | DECLARATIVE OBJECT IDENTITY USING RELATION TYPES - The present invention provides a programming model based on a relational view of the heap which defines identity declaratively, obviating the need for equals( ) and hashcode( ) methods. Each element in the heap (called a tuple) belongs to a relation type and relates an immutable identity to mutable state. The model entails a stricter contract: identity never changes during an execution. Objects, values, and singletons arise as special cases of tuples. | 09-11-2008 |
| 20080235661 | SYSTEM AND METHOD FOR USING ANNOTATIONS TO AUTOMATICALLY GENERATE A FRAMEWORK FOR A CUSTOM JAVASERVER FACES (JSF) COMPONENT - A system and method for using annotations to automatically generate a framework for a custom JavaServer Faces (JSF) component is provided. Source code for a custom JSF Component class may be received, where the received source code may include annotations indicating how a declared element should be processed. For example, based on a type of annotation in the source code, the framework for the custom JSF component may be automatically generated, where the generated framework can include implementations for a Component class, a Tag Handler class, a Renderer class, a Tag Library Descriptor, a faces-config.xml file, tag unit test cases, or any other aspect of a custom JSF component. Thus, reusable, reliable, and readable custom JSF components may be easily developed at a substantially reduced development cost. | 09-25-2008 |
| 20080244516 | VARIABLE CAPTURE IN OBJECT ORIENTED LANGUAGES - Systems and methods facilitate variable capture with respect to closures in object oriented programming languages. In particular, multiple copies of closure variables are generated such that lifetime of variables is defined by variable scope. However, if a previous version of a variable exists, a newly created variable is initialized with the value of the previous version. | 10-02-2008 |
| 20080301635 | Per-instance and per-class aspects - An object-oriented program development tool supports the specification and implementation program aspects. Cross-cutting concerns can be identified, and key points in a program augmented with arbitrary functionality. Classes and individual objects can be associated with different advices. Interceptors can be added dynamically on a per-instance and/or a per-class basis. | 12-04-2008 |
| 20080313612 | HYSTERESIS FOR MIXED REPRESENTATION OF JAVA BIGDECIMAL OBJECTS - A computer implemented method for determining when to change a representation type of at least one number stored in a memory of a data processing system. An operation is received in a processor of the data processing system. The operation references a number stored as a class of an object-oriented programming language. The number is stored as a first representation type. Responsive to the operation being biased towards the first representation type, a first counter is incremented. Responsive to the operation being biased towards a second representation type, a second counter is incremented. A counter reference is equal to a first value of the first counter subtracted from a second value of the second counter. Responsive to the counter reference exceeding a threshold number, representation of a subsequent number is changed from the first representation type to the second representation type. | 12-18-2008 |
| 20080313613 | Method for statically checking an object-oriented computer program module - A method for statically checking an object-oriented computer program module includes the step of identifying objects within a computer program module, at least one of the objects having a plurality of references thereto, possibly from multiple clients. A discipline of permissions is imposed on the objects identified within the computer program module. The permissions enable tracking, from among a discrete set of changeable states, a subset of states each object might be in. A determination is made regarding whether the imposed permissions are violated by a potential reference to any of the identified objects. The results of the determination are output to a user. | 12-18-2008 |
| 20090019424 | SYSTEM AND METHOD OF APPLICATION CONTEXT DRIVEN ACCESS RESTRICTION - A method and system for providing application context restrictions are provided. The method may include, responsive to a request from a first object to a second object, comparing an application context of the first object with an application context of the second object. The method may include, if the comparison succeeds as determined by predefined rules, allowing a response from the second object to be transmitted to the first object. The method may include, if the comparison fails as determined by predefined rules, restricting the response from the second object to the first object. | 01-15-2009 |
| 20090024983 | OBJECT BASED BROWSING SUITABLE FOR USE IN APPLICATIONS - A method, system and computer program product for object based browsing suitable for use in various applications is provided. The method includes receiving one or more working lists. Thereafter, one or more rules corresponding to the one or more working lists are checked. One or more context menus for the one or more working lists are then dynamically generated based on the checking. | 01-22-2009 |
| 20090031285 | RUN-TIME TYPE CONVERSION - A method, system and computer program product for converting a class (i.e., type) of an object from a first class to a second class. Multiple classes, class layouts, and an object layout are received. A first class layout references a first virtual function table (v-table) that defines behaviors of the first class. A second class layout references a second v-table that defines behaviors of the second class. The object layout includes a reference to the first v-table to define runtime behaviors of the object as the behaviors of the first class. At runtime, the reference in the object layout is modified to reference the second v-table to update the object's runtime behaviors to the behaviors of the second class, thereby converting the object from the first class to the second class without changing to an object layout memory address or to any class layout. | 01-29-2009 |
| 20090070739 | System and method of communicating between heterogeneous systems - A method and system are provided for communicating between two heterogeneous systems in an enterprise services architecture. A software object on a first system is associated with a node, a node attribute, an action, and a query. The software object is then formatted, or converted, into a generic version of the software object before contact with a user interface of a second system. The contact with the user interface of the second system is then made. | 03-12-2009 |
| 20090070740 | SYSTEM FOR STORING AND MANAGING OBJECTS - A system of the present invention includes a storage device for distinguishably storing old objects that are objects having existed for not less than a predetermined period since being generated and new objects that are objects having existed for less than the predetermined period since being generated. Then, a new object that has existed for less than the predetermined period since being generated is selected from the storage device, and an old object having the same content as the selected new object is searched for. If such an old object is not found, the selected new object is newly stored as an old object in the storage device. If the old object is found, a reference to the selected new object is integrated with a reference to the found old object. If the old object is stored, the reference to the selected new object is changed to a reference to the stored old object. | 03-12-2009 |
| 20090077536 | PROGRAMMING ENVIRONMENT WITH SUPPORT FOR HANDLE AND NON-HANDLE USER-CREATED CLASSES - A language processing environment provides facilities for defining and using handle classes. A handle class is a class that always and only exists as a handle to stored data, yet that data is accessed in the same manner as with non-handle classes. The language processing environment provides syntax such that all values in the language are members of some class and all classes are defined using the same syntax. Methods and properties are supported on both handle and non-handle classes. | 03-19-2009 |
| 20090089748 | Accelerated Cached Object Retrieval - Efficiency of cached objects such as singleton objects and other software constructs having a first-invocation cost is improved by replacing the software code for creating a method instance (the “creation code”) with the instance itself. Upon first invocation, the calling method causes the first version of the method to be performed, and also causes the first version to be replaced by the second version. Thus, the invention facilitates creation of singleton objects that run without any branch logic, so as to improve speed and efficiency. The need for locking and exception handling is reduced, resultant code is simplified, and potential for error is reduced. | 04-02-2009 |
| 20090119642 | System and Method of Executing a Dynamic Program in a Structured Environment - In one embodiment the present invention includes a first virtual machine that executes a non-dynamic program, that implements a second virtual machine that executes a dynamic program. The dynamic program operates in the structured environment of the non-dynamic programming language via various allowed interaction pathways. In this manner, dynamic programs may be executed in a robust business applications environment. | 05-07-2009 |
| 20090125882 | METHOD OF IMPLEMENTING HYPEROBJECTS IN A PARALLEL PROCESSING SOFTWARE PROGRAMMING ENVIRONMENT - In embodiments of the present invention improved capabilities are described for a runtime system for a multiple processing computing system, where multiple processing strands are implemented with hyperobjects. The hyperobject may be a reducer, a splitter, and the like, where the hyperobject may be considered a linguistic object that enables the operation of a plurality of views in the multiple processing environment. The runtime system may implement the hyperobject by managing operations on views, including one or more of creation, accessing, modifying, transferring, forking, combining, and destruction. Access of the views may happen independently from the linguistic control constructs of the code operating on the runtime system and may maintain the identity of the object so that any updating of the object results in updating of a view. | 05-14-2009 |
| 20090138850 | PROCESSING DEVICE FOR EXTRACTING IMMUTABLE ENTITY OF PROGRAM AND PROCESSING METHOD - An unclassified, an immutable entity, a mutable entity, and a neutral entity as kinds of classes are provided. Then all of the classes of a parsed object-oriented program are initially classified as unclassified, and the classifications are changed based on at least a field information and at least parent-child information. Any class that remains unclassified after the classification changes is changed to an immutable entity. Information is output about the classes classified as the immutable entity as immutable entity extraction information. | 05-28-2009 |
| 20090150863 | Type checking for object-oriented programming languages - Type checking between an object class and a target class may comprise getting an object header from an object, and checking from the object header a result of a first time type checking between a class of the object and a target class specified by a hotspot in the first time type checking. | 06-11-2009 |
| 20090150864 | DECLARATIVE OBJECT IDENTITY - Systems and methods are described that enhance a programming language by introducing support for declarative object identity in both class declarations and object literals. An exemplary system includes a memory that stores code associated with a computer program and a component coupled to the memory. The component is configured to access the code, to identify a variable in the code and a modifier associated with the variable and, responsive to identifying the variable, to use the variable to determine the identity of an object associated with the variable and to determine whether the object is equal to another object based on value semantics. | 06-11-2009 |
| 20090158252 | Method for Creating an Approximation Graph Relating to the Behavior of the Man-Machine Interface of an Application - An approximation graph for behaviors of the man/machine interface of an application that is obtained automatically by this method can be defined as follows: the nodes (N | 06-18-2009 |
| 20090172638 | Adding Functionality To Existing Code At Exits - New code is added to existing object code in order to add new functionality. For example, a call to start a profiler function can be added at the beginning of a Java method and a call to stop the profiler function can be added at the exits of the Java method. A method may have many different exits. To insure that the profiler process is stopped regardless of which exit is performed, the byte code and exception table are modified. | 07-02-2009 |
| 20090222794 | UNIFIED EXPRESSION AND LOCATION FRAMEWORK - Allowing a continuation based runtime to resolve different types of location expressions, value expressions, and/or locations. This may be accomplished using a different class for each particular type. The location expression classes may each have a common method used for all of the location expression classes. The value expression classes may each have a common method, and the locations may also each have a common method. This allows the resolution of such location and value expressions to be treated in a unified fashion regardless of the type of location expression, or the type of value expression. Also, the location may be treated in a unified manner regardless of the type of location. | 09-03-2009 |
| 20090249293 | Defining Workflow Processing Using a Static Class-Level Network in Object-Oriented Classes - Methods for configuring a computer-implemented workflow process in a computing environment include defining a workflow class using an underlying object oriented programming language of the computing environment as a metalanguage, and extending the workflow class with a static class-level model that defines a flow network, | 10-01-2009 |
| 20090271765 | CONSUMER AND PRODUCER SPECIFIC SEMANTICS OF SHARED OBJECT PROTOCOLS - Determining how to perform operations specified in executable code. A method may include accessing a language context. The language context is related to a consumer location in executable code. The language context specifies an operation to be performed on one or more objects. The method includes sending a message requesting information about how to perform the operation on the one or more objects. A meta-object is received. The meta-object includes or produces executable code, that when executed performs the operation on the one or more objects. | 10-29-2009 |
| 20090288068 | DOMAIN MODEL CONCEPT FOR DEVELOPING COMPUTER APPLICATIONS - Methods and systems for developing a computer application wherein a domain specific language is provided that allows for the developing of computer applications based on a configuration. In particular, the domain specific language pertains to calculation tasks. The developing of a computer application is performed at different levels or phases. In particular, these phases are the providing of an application development system in the design phase, performing the application configuration and executing the application. The design phase provides the application design environment and provides the abstract basis for the application development in the sense of configuration classes and domain-specific language. For the specific configuration of an application in a particular project, i.e. for the development of a specific application, resources as elements and their associations are defined. This configuration is stored in a configuration file. At run time, an application is generated which instantiates the resources and configured elements. Within the generated graphical user interfaces of the application the instantiated resource objects are provided and the calculation is performed according to the configured element assignment. | 11-19-2009 |
| 20090313603 | System And Method For Creating Virtual Callback Objects - A method for creating a virtual callback object using a client callback object. A client device executes a client application. A client callback object is used by the client application in a client/server transaction between a server device and the client device. A recorder module captures the client/server transaction between the client device and the server device, and the client callback object is used in the client/server transaction. Internal client operations may be filtered from the client callback object to create the virtual callback object. A script may be generated using the virtual callback object. | 12-17-2009 |
| 20090319990 | OBJECT ORIENTED GENETIC PROGRAMMING - Methods and systems for performing object oriented genetic programming are provided. According to one embodiment, a population of computer program representations are varied to create a new population by generating additional computer program representations based on those of the computer program representations selected in accordance with a selection strategy. Each computer program representation is modeled as a linear array of genes, each gene having domain-specific values and an action or operation to be performed on the basis of the domain-specific values. It is determined whether any computer program representations of the new population satisfy any predetermined performance criteria. If so, then such computer program representations are identified as potential solutions to the problem at issue; otherwise, subsequent generations are generated until one or more predetermined performance criteria are satisfied. | 12-24-2009 |
| 20090327999 | IMMUTABLE TYPES IN IMPERITIVE LANGUAGE - An imperative framework having a more than one type is defined. At least one of the types is an immutable type, and the immutable type has at least one immutable field. | 12-31-2009 |
| 20100005448 | COMMUNICATION OF INFORMATION BETWEEN A PLURALITY OF NETWORK ELEMENTS - A communications protocol interface is configured as being divisible into a core portion and an extensible portion. The extensible portion of the communications protocol interface is further configured to be customized in scope so that each network element can communicate a unique and optionally small, subset of actual interoperable data that corresponds to at least a portion of a larger defined data set. A software generator program is configured to generate a set of extensible source code that operates upon the subset of actual data and that directs the execution of the extensible portion of the communications protocol interface for a particular network element. | 01-07-2010 |
| 20100058293 | DETOURING IN SCRIPTING SYSTEMS - A system described herein includes a receiver component that receives third party code for execution in a host environment, wherein the third party code corresponds to a dynamic programming language, and wherein the third party code has at least one object reference to a first object that is used by the third party code. A detouring component automatically replaces the first object referenced by the third party code with a proxy object such that the third party code at runtime calls the proxy object instead of the first object. | 03-04-2010 |
| 20100125829 | COMPONENT-BASED WEB APPLICATION DEVELOPMENT FRAMEWORK USED FOR CREATING WEB PAGE - The present invention relates to a user interface server framework and a method of using the framework, which supports a user interface developer to develop a final user interface based on components. The component-based web application development framework used for creating a web page comprises a runtime engine for executing a method of a business object and returning a result of executing the method in response to a user's request; a script component for performing a preprocessing on a user input value before executing the method of the business object, performing a post-processing on the result of executing the method after executing the method of the business object, and dynamically arranging a user interface object; and a core component for initializing the framework and confirming whether the user's request can be processed in the framework. | 05-20-2010 |
| 20100146482 | AUTOMATIC COPYING BY ANCESTOR IN OBJECT-ORIENTED LANGUAGES - A method of automatically defining a new class in a class hierarchy includes creating a descendent class that descends from one or more specified ancestor classes; sequentially analyzing each class along each inheritance path from the specified ancestor classes to a specified similar class to identify each class item in each class that is not selected from the specified ancestor classes; storing a respective pointer for each class item identified in each class that is not inherited by the class referencing the class item and associated with the class; storing a respective pointer for each class item identified in each class that is inherited and redefined by the class referencing the class item and being associated with the class if a pointer referencing the class item is not already stored; and copying each class item referenced by a stored pointer to the descendent class. | 06-10-2010 |
| 20100186002 | METHOD AND SYSTEM FOR SYNCHRONOUS OPERATION OF LINKED COMMAND OBJECTS - A system and method provide for synchronous operation of linked command objects in a general purpose software application. The software application provides a user with a variety of operations that manipulate available data objects. The software application manages the data objects in a number of contexts. Each context manages the existence and execution of a number of command objects. Each command object operates on one or more data objects in its context. To support synchronous operations that affect the state of data objects in more than one context, command objects are linked to each other. When one command object is executed, the context of the command object identifies a command object linked to the executed command object and initiates the execution of the linked command object via the context that manages that command object. This synchronization allows for synchronous undo and redone operations. The delete states of the command objects are also synchronized. Deleting a command object destroys it, and prevents it from being undone. When one command object is deleted the command object linked thereto is also deleted, thereby preventing the linked command object from being independently undone resulting in an inconsistent state of the contexts. | 07-22-2010 |
| 20100262951 | SYSTEM AND METHOD FOR GENERATING A WIRELESS APPLICATION FROM A WEB SERVICE DEFINITION - System and method for creating a wireless application from a web service definition language employs an algorithm that analyzes each message of the web service definition an maps the message to a wireless application message and a wireless application data structure. The message maps are used by a proxy at an edge of a wireless network to convert web service messages to wireless messages, and vice versa. | 10-14-2010 |
| 20100306739 | FAST LATE BINDING OF OBJECT METHODS - An apparatus and a method for managing class properties in a computer program is described. Classes are declared. Each class is associated with a corresponding method with at least one class inheriting one or more method corresponding to one or more other classes. A table generator forms a table of methods and references associated with each class. The table is copied forward with each inheritance declaration. A reference to a method of a class is resolved by retrieving the table associated with a current instance's class and resolving from the table associated with the class corresponding to an object from which the method is referenced. | 12-02-2010 |
| 20110004866 | COMBINING CLASSES REFERENCED BY IMMUTABLE CLASSES INTO A SINGLE SYNTHETIC CLASS - A system and method for creating synthetic immutable classes. A processor identifies first and second classes, instances of which include first and second data fields, respectively. The first data fields include a data field that references the second class. In response to determining that the first class is immutable and the second class is immutable, the processor constructs a first synthetic immutable class, an instance of which comprises a combination of the first data fields and the second data fields. The processor creates an instance of the first synthetic immutable class in which the first data fields and the second data fields occupy a contiguous region of a memory. In response to determining the first synthetic immutable class does not include an accessor for the second class, the processor combines header fields of the first and second data fields into a single data field in the first synthetic immutable class. | 01-06-2011 |
| 20110016450 | SYSTEM AND METHOD OF MERGING OF OBJECTS FROM DIFFERENT REPLICAS - A first object, typically a software source code object, is checked-in at a first replica of a base object. The replica typically comprises a plurality of objects (e.g., a source code base for a software project). The first object is a version of a base object. The first object is then delivered to a second replica of the base object. If it is determined at the second replica that a trivial merge cannot be performed between the first object and the current base object, the current base object is delivered to the first replica. The first object is rebased with the current base object. The rebased first object is sent to the second replica and a trivial merge is performed between the rebased first object and the current base object. | 01-20-2011 |
| 20110035728 | Object-Oriented Support for Dynamic Assignment of Parallel Computing Resources - Improvements to object-oriented programming methods allow programmers to direct execution of dynamically generated, parallel computing tasks on variety of platforms. Data objects provide their data location information handle, plurality of which can be combined by arithmetic operations, thus providing application specific, computing platform non-specific method to inform executing environment about data needed for each programming object. During execution this information is used to produce platform specific data structure to aid in optimal processing node assignment. A new calling method greatly reduces data exchanges between objects running as separate tasks. These improvements are particularly well suited to programming method and computing machine presented by parent of this divisional patent application. As parent invention utilization results in dynamic allocation of large number of tasks, assignment of processing nodes at runtime to those tasks, load balancing with various distributed resource access schemes are critical problems to solve. | 02-10-2011 |
| 20110078657 | OPERATION MANAGEMENT SERVER, ROLLBACK EXECUTION METHOD, AND ROLLBACK EXECUTION PROGRAM - When a failure occurred, the state of a system is returned to a state before the failure. An operation management server for managing operation of an application using Java® includes: an update processing execution unit which, when a method which involves update of data is called up, obtains pre-update data which is a target of the update and executes update processing corresponding to the method; a first abnormal end determination unit which determines whether the update processing has ended abnormally; a first rollback unit, which, when the update processing has ended abnormally, returns the update processing target data to the pre-update data; an operation processing execution unit which, when a method which does not involve update of data is called up, executes operation processing corresponding to this method, a second abnormal end determination unit which determines whether the operation processing has ended abnormally; and a second rollback unit, which, when the operation processing has ended abnormally, returns the state to the state before execution of the operation processing. | 03-31-2011 |
| 20110185344 | CHARACTERIZING ARTIFICIALITY IN OBJECT CODE - One embodiment of the present invention provides a system that characterizes content in object code. During operation, the system receives the source code of a program. The system also receives one or more pieces of object code of the program, or creates one or more pieces of object code from the source code. Next, the system identifies a construct in the object code. The system then determines whether the construct is physically present in the source code. If the construct is not physically present, the system determines whether the construct is logically present in the source code, wherein a construct is logically present if it is required by the programming language. If so, the system sets a construct flag to indicate that the construct is “synthesized.” However, if not, the system sets the construct flag to indicate that the construct is “synthetic.” Finally, the construct flag is made available to a reflective API. | 07-28-2011 |
| 20110314448 | Synthetic Partitioning for Imposing Implementation Design Patterns onto Logical Architectures of Computations - A method and a system for using synthetic partitioning constraints to impose design patterns containing desired design features (e.g., distributed logic for a threaded, multicore based computation) onto logical architectures (LA) specifying an implementation neutral computation. The LA comprises computational specifications and related logical constraints (i.e., defined by logical assertions) that specify provisional loops and provisional partitionings of those loops. The LA contains virtually no programming language constructs. Synthetic partitioning constraints add implementation specific design patterns. They define how to find frameworks with desired design features, how to reorganize the LA to accommodate the frameworks, and how to map the computational payload from the LA into the frameworks. The advantage of synthetic partitioning constraints is they allow implementation neutral computations to be transformed into custom implementations that exploit the high capability features of arbitrary execution platform architectures such as multicore, vector, GPU, FPGA, virtual, API-based and others. | 12-22-2011 |
| 20110321009 | IMPLEMENTING ENCRYPTION VIA ASPECT ORIENTED PROGRAMMING - A device may include a processor. The processor may be configured to read an aspect, and identify, within a program, code for instantiating an object output stream object based on the aspect. In addition, the processor may be configured to replace, within the program, the code for instantiating the object output stream object with code for instantiating secure object output stream object. Furthermore, the processor may be configured to generate a compiled program from code obtained by replacing, in the program, the code for instantiating the object output stream object with the code for instantiating the secure object output stream object. The processor may be configured to write the compiled program to a file. | 12-29-2011 |
| 20110321010 | WEB APPLICATION FRAMEWORK BASED ON OBJECT ORIENTED CLASS MAPPING - A method and system for building a web application framework is provided. This framework explicitly maps each dynamic web page to a class method, called “web service” method. Each MIME type of static web pages is implicitly mapped to a predefined web service method of a system class. All related web service methods are grouped into one object class, in which a business unit of coupled dynamic web pages is bind together to construct a natural web user session implicitly. Each web service class is logically divided into four segments, which is described by a paradigm, called “STUD” (acronym for Services, Templates, Utilities and Data). A new data exchange format, called “SDON” (acronym for Simple Data Object Notation), is defined to represent a structured data exchanged between web client and web server or passed among web servers. A SDON data string can be directly reflected into an object of the data class type. Each data source related to a relational database is mapped to a three tier structure of classes (schema, table, and data record). The data record classes inherit the names of tables inside the database. | 12-29-2011 |
| 20120005652 | Method and System for Lazy Data Serialization in Computer Communications - A method of transmitting information to a receiving computer systems includes determining in a processing unit of a computer whether a receiving computer system can receive the information without converting a local format of the information into a canonical format of the information, if it is determined that the receiving computer system cannot receive the information without converting the local format into the canonical format, then converting the local format to the canonical format and transmitting the information to the receiving computer system, and if it is determined that the receiving computer system can receive the information without converting the local format into the canonical format, then transmitting the information to the receiving computer system. | 01-05-2012 |
| 20120102456 | System and Method of Annotating Class Models - In one embodiment the present invention includes a computer-implemented method of annotating software objects. The method includes storing rules that define how to annotate a software object. The method further includes processing the software object according to the rules. The method further includes generating an annotation document based on the software object having been processed according to the rules. The method further includes generating an annotated software object based on the software object and the annotation document. As a result, annotated software objects may be generated in a dynamic, non-intrusive manner. | 04-26-2012 |
| 20120131551 | Peculiar Objects - 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. | 05-24-2012 |
| 20120167043 | Virtual Machine Tool Interface For Tracking Objects - Disclosed is a method to track allocation of a plurality of objects in a heap. A data processing system, during an object allocation, prevents an object from being moved to another place in memory or being deleted. The data processing system prevents such activity concurrently with garbage collection on a second object not currently being allocated. The data processing system notifies a profiler of object information based on the object allocation via a callback function, wherein object information is a one-to-one mapping of the object address. The data processing system revives garbage collector processing of the object. | 06-28-2012 |
| 20120174063 | LOGICAL ADDRESS BASED OBJECT ORIENTED PROGRAMMING - Disclosed are methods and systems for generating resource with URI. The methods and systems involve receiving a request for processing a data, the request including an uniform resource identifier (URI), based on the URI, sending the request to an associated resource handler, instantiating set of data resources associated with the URI by calling a resource factory and processing the request by passing the set of data resources to a specific application programming interface for presenting instantiated set of data resources. | 07-05-2012 |
| 20120240102 | OBJECT REPLACEMENT METHOD, SYSTEM AND COMPUTER PROGRAM PRODUCT - Replacing an object in an object oriented model in a computer system, by interrogating the model to retrieve information defining the relationships between the object to be replaced and other components of the model is described. These relationship definitions are then used to configure the replacement object within the model so as to assume corresponding relationships with the other components. There may be established as a part of the model functions to detect changes to the relationships between objects belonging to the model, and recording the changes in a registry. This registry is then interrogated to retrieve relationship definitions necessary to replace an object. | 09-20-2012 |
| 20130007703 | EXTRACTION OF FUNCTIONAL SEMANTICS AND ISOLATED DATAFLOW FROM IMPERATIVE OBJECT ORIENTED LANGUAGES - Extraction of functional semantics and isolated dataflow from imperative object oriented languages, in one aspect, may include identifying one or more methods and/or classes associated with one or more of a plurality of property labels in a computer code written in object oriented language to extract functional and isolation characteristics in the computer code. The plurality of property labels supported by one or more checking rules, are used to verify that the one or more methods and/or classes identified with the plurality of property labels have isolation characteristics. An object oriented language compiler is provided for supplying the plurality of property labels and checking rules. The object oriented language compiler further may include capability to transform methods into compute tasks and connect the compute tasks so as to create a dataflow graph. | 01-03-2013 |
| 20130061207 | PARALLELIZATION AND INSTRUMENTATION IN A PRODUCER GRAPH ORIENTED PROGRAMMING FRAMEWORK - Embodiments of parallelization and/or instrumentation in a producer graph oriented programming framework have been presented. In one embodiment, a request to run an application program is received, wherein object-oriented source code of the application program includes methods and producer dependency declarations, wherein the producer dependency declaration for a given method identifies a set of zero or more producers with outputs that are an input to the given method, wherein a producer is at least an instance and a method associated with that instance. Further, execution of the application program may be parallelized based on dependency between producers of the application program using the runtime. In some embodiments, the application program is instrumented using the runtime. | 03-07-2013 |
| 20130074037 | Analytic engine to parallelize serial code - The subject system provides the ability to parallelize pre-existing serial code by importing and encapsulating all of the serial code into an object orientated flowchart language utilizing an analytic engine so that the imported code can be efficiently executed taking advantage of the partially ordered transitive flowchart system. The importation examines the serial code to ascertain what elements may be processed under an atomic time to instantiate them as either Action or Test objects, whereas statements which require more than atomic time are instantiated as Task object, with the Action, Test and Task objects being processable by separate processors to establish parallel processing, or by the multitasking afforded by the partially ordered transitive flowchart system. | 03-21-2013 |
| 20130086552 | SYSTEMS AND METHODS FOR APPLYING DYNAMIC RELATIONAL TYPING TO A STRONGLY-TYPED OBJECT-ORIENTED API - A computer-implemented method includes executing instructions stored on a computer-readable medium. The computer-implemented method includes receiving, at a server hosting a strongly-typed object-oriented application programming interface (API), a single API call to request data from the strongly-typed object-oriented API, where the single API call includes a tuple having multiple object types, obtaining the requested data and returning the requested data. | 04-04-2013 |
| 20130159969 | DIGITAL SIGNAL PROCESSING WITH LANGUAGE INTEGRATED MONADS - Digital signal processing is facilitated utilizing monads. In other words, a digital signal can be processed as a function of at least one monadic operation over the digital signal. Monadic operations can also be integrated into a general-purpose programming language optionally in a declarative syntax to further facilitate programming with respect to digital signals. | 06-20-2013 |
| 20130219357 | COHERENT PRESENTATION OF MULTIPLE REALITY AND INTERACTION MODELS - A method for navigating concurrently and from point-to-point through multiple reality models is described. The method includes: generating, at a processor, a first navigatable virtual view of a first location of interest, wherein the first location of interest is one of a first virtual location and a first non-virtual location; and concurrently with the generating the first navigatable virtual view of the first location of interest, generating, at the processor, a second navigatable virtual view corresponding to a current physical position of an object, such that real-time sight at the current physical position is enabled within the second navigatable virtual view. | 08-22-2013 |
| 20130239088 | TRANSACTIONAL OBJECT CONTAINER - A processing device receives a transactional object at runtime of a compiled application, the transactional object comprising first transactional logic. The processing device determines a locking strategy to use for the transactional object. The processing device generates a transactional proxy for the transactional object, the transactional proxy comprising a transactional marker, a pointer to the transactional object, and second transactional logic that supersedes the first transactional logic. The processing device passes the transactional proxy to the application, wherein the application is to make calls on the transactional proxy instead of on the transactional object. | 09-12-2013 |
| 20130298108 | SYSTEM AND METHOD FOR SUPPORTING A DEFERRED REFERENCE TO AN OBJECT IN AN OBJECTED-ORIENTED PROGRAMMING LANGUAGE ENVIRONMENT - A system and method can support a deferred reference in an object-oriented programming language environment. The object-oriented programming language environment can include an interface that can provide a deferred reference to an object that will be available at a future time. Furthermore, after receiving a request from a caller to get the object based on the deferred reference, the interface can return the object to the caller when the object is available or can indicate to the caller when the object is not currently available and/or when the object will never become available. | 11-07-2013 |
| 20130305220 | METHOD AND PROGRAM FOR RECORDING OBJECT ALLOCATION SITE - A method, system, and program for recording an object allocation site. In the structure of an object, a pointer to a class of an object is replaced by a pointer to an allocation site descriptor which is unique to each object allocation site, a common allocation site descriptor is used for objects created at the same allocation site, and the class of the object is accessed through the allocation site descriptor. | 11-14-2013 |
| 20140053132 | LANGUAGE INTEGRATION VIA FUNCTION REDIRECTION - Systems and methods for language integration via function redirection are disclosed herein in connection with simulation of quantum computations on classical computers. A base class that all of the functions of a group will instantiate in their context may be defined. The functions may take arguments that may be passed to a member of the base class for dispatch. A dispatcher may be provided to analyze the current context. The dispatcher may perform any of a number of operations as a result, including, but not limited to, passing the arguments to the class instance for execution, returning the class instance directly or via a context holder, returning a new representation of the function for future execution via a context holder, or any other return type that may be desired. | 02-20-2014 |
| 20140068557 | STRONGLY TYPED METADATA ACCESS IN OBJECT ORIENTED PROGRAMMING LANGUAGES WITH REFLECTION SUPPORT - Type safety is important property of any type system. Modern programming languages support different mechanisms to work in type safe manner, e.g., properties, methods, events, attributes (annotations) and other structures, but none of the existing, general purpose, programming languages which support reflection provide type safe type (class/structure) member metadata access. Existing solutions provide no or limited type safety which are complex and processed at runtime which by definition is not built-in type-safe metadata access, but only more or less type safe workarounds called “best practices”. Problem can be solved by introducing method for type safe type member metadata access which could be processed at compile time. | 03-06-2014 |
| 20140082589 | MODULE MANAGEMENT APPARATUS, MODULE MANAGEMENT SYSTEM AND MODULE MANAGEMENT METHOD - There is provided a module management apparatus, that coordinates, in a time of start of a module management infrastructure carrying out integrated management of: a bundle having a module formed by a program described by an object oriented language and definition information including an attribute of the module; and a module group including a plurality of pieces of the bundle, when the bundle is loaded from a folder, and, if the definition information collides between different bundles, a reference relationship of the bundle by changing the definition information dynamically. | 03-20-2014 |
| 20140109045 | FLEXIBLE AND RUN-TIME-MODIFIABLE INCLUSION OF FUNCTIONALITY IN COMPUTER CODE - The current application is directed to flexible and run-time-modifiable implementation of crosscutting functionalities, including code instrumentation, error logging, and other such crosscutting functionalities. These crosscutting functionalities generally violate, or run counter to, modern code-development strategies and programming-language features that seek to partition logic into hierarchically organized compartments and modules with related functionalities, attribute values, and other common features. One feature of the methods and systems for implementing crosscutting functionalities to which the current application is directed is an intelligent switch that can be controlled, at run time, to alter invocation and behavior of crosscutting-functionality implementations, including data-collection instrumentation, error logging, and other crosscutting-functionality implementations. | 04-17-2014 |
| 20140173557 | 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. | 06-19-2014 |
| 20140196008 | IMMUTABLE OBJECT TYPES - A language extension that advances safety in system programming in that an entire type may be declared to be immutable in the case in which all instances of that type are immutable. The immutable type declaration automatically causes any instances of that type to be treated as immutable, and automatically causes all directly or indirectly reachable members (e.g., fields, methods, properties) of the instance to also be treated as immutable. Furthermore, any construction time reference that allows for field assignment of the instance is not permitted to survive beyond the point at which the instance becomes accessible to its creator. Accordingly, this instance, and any other instance of that same type, will be immutable from the very time of construction. The ability to classify all such instances as immutable is beneficial as the immutable characteristic permits actions that normally would not be allowed due to resource access safety. | 07-10-2014 |
| 20140282391 | Node Grouped Data Marshalling - Node Grouped Data Marshalling may involve converting programming objects to marshalled data. A marshaller application may determine a class type for each of the programming objects to be marshalled. Two or more of the objects may be of the same class type and may derive from a shared base class. The marshalling application may group of the objects based on the objects' class types. The objects may be marshalled using a set of key-value pairs where keys may identify the class type of an object and where the values may represent the contents of the object and may itself be a set of key-value pairs. A marshalling application may generate a textual representation of the objects such that each grouping of class types is identified by a single key name. | 09-18-2014 |
| 20140282392 | PROGRAMMING MODEL FOR PERFORMANT COMPUTING IN DOCUMENTORIENTED STORAGE SERVICES - Object-oriented application languages often provide resources to applications for accessing objects stored in the volatile application memory region, and, separately, for packaging objects for persistent storage and network transport by serialization and deserialization involving a storage format. However, this design creates discrepancies between the application language and storage format, and depends on affirmative serialization and deserialization by the application. Presented herein are techniques for providing object access to objects involving persisting the objects as documents in a document store, where such persistence occurs automatically upon object creation and updating, and where such objects are stored in a language format integral to the application language (e.g., when a JavaScript application creates an object, the objects are automatically stored as documents of the document store in a JavaScript Object Notation (JSON) format). This design enables various advantages in efficiency, flexibility, and seamless interaction between the application and the objects. | 09-18-2014 |
| 20150040102 | SYSTEM AND METHOD FOR SOFTWARE INTEROPERABILITY - A software interoperability system includes at least one processor, at least one computer-readable tangible storage device, and program instructions stored on the at least one storage device for execution by the at least one processor. The program instructions include first program instructions configured to map a program operation of a first programming type to a programming operation of a second programming type. The program instructions further include second program instructions configured to generate a first programming type representation of an object associated with the program operation of the second programming type based on the map. The program instructions further include third program instructions configured to effect an invoked instance of the first programming type representation via an interface associated with the second program type. | 02-05-2015 |
| 20150106786 | SYMMETRICAL DIMENSIONS IN CONTEXT-ORIENTED PROGRAMMING TO OPTIMIZE SOFTWARE OBJECT EXECUTION - A method, system, and/or computer program product optimizes execution of a computation. Multiple slots, each of which is a container for information, are defined. A coordinate tuple is defined for each of the multiple slots. The coordinate tuple describes a position of a slot along multiple dimensions in a slot space. The multiple dimensions describe roles for executing a software object, and each of the multiple dimensions has a same level of primacy such that no dimension has primacy over another dimension in the slot space. Multiple method slots are populated with software method objects that address different contexts and purposes as defined by coordinate tuples of the multiple method slots. Software method objects are retrieved from coordinate tuples in the slot space that match a defined context and purpose of a particular computation, which is propagated to a processor that is executing a particular software method object. | 04-16-2015 |
| 20150324175 | RESOURCE ACCESS SAFETY THROUGH IMMUTABLE OBJECT TYPES - A language extension that advances safety in system programming in that an entire type may be declared to be immutable in the case in which all instances of that type are immutable. The immutable type declaration automatically causes any instances of that type to be treated as immutable, and automatically causes all directly or indirectly reachable members (e.g., fields, methods, properties) of the instance to also be treated as immutable. Furthermore, any construction time reference that allows for field assignment of the instance is not permitted to survive beyond the point at which the instance becomes accessible to its creator. Accordingly, this instance, and any other instance of that same type, will be immutable from the very time of construction. The ability to classify all such instances as immutable is beneficial as the immutable characteristic permits actions that normally would not be allowed due to resource access safety. | 11-12-2015 |
| 20160062743 | System Integrator and Method for Mapping Dynamic COBOL Constructs to Object Instances for the Automatic Integration to Object-Oriented Computing Systems - A system integrator for modeling an object instance of a COBOL data set, the object instance including representations of OCCURS DEPENDING ON clauses or REDEFINE clauses. The system comprises a client interface module, an import module, an object model module and modeler module. The client interface module generates an interface and receives a copybook selection and a set of REDEFINE criteria. The import module receives the copybook selection and imports a copybook from a database. The object model module receives the copybook and the set of REDEFINE criteria, and creates a customized object model for the copybook. The modeler module receives the customized object model and a set of COBOL data, and forms an object instance equivalent to the set of COBOL data, the object instance including representations of a OCCURS DEPENDING ON clause or REDEFINE clause. | 03-03-2016 |
| 20160070545 | FACTORY IDENTIFICATION SYSTEM - The described technology is directed towards a factory identification system, in which a factory object is provided with a factory identifier (ID) that specifies information regarding a desired object that is more specific than specifying an interface. Additional construction parameters such as an object ID may be provided to further describe the desired object. Also described are object caching and reuse, and tagging the object with information that may be preserved and later used to recreate an object. | 03-10-2016 |
| 20160070579 | OBJECT-ORIENTED PROGRAMMING SYSTEM AND LIBRARY - The described technology is directed towards an object-oriented programming (OOP) system and library that maps conventional object-oriented concepts such as class hierarchies, interfaces, and static methods and properties onto a prototypal object system such as JavaScript®. Various functions of the OOP system are called to create a class-like structure that is instantiated into an object instance upon request. The OOP system allows for use of a wrapper pattern to wrap selected objects with added functionality such as validation and tracing, and to provide enhanced functionality with respect to properties, such as to call a function associated with a property when the property's value changes, and/or to lazily generate property values only when accessed. | 03-10-2016 |
| 20160196114 | APPARATUS AND METHOD FOR REALIZING RUNTIME SYSTEM FOR PROGRAMMING LANGUAGE | 07-07-2016 |
