Abstract: Controlling how changes made to a version of a reusable component (e.g., for displaying in a graphical user interface) are applied, or not applied, to another version or versions of that component. A variation is defined, the variation comprising a set of overridden property values for the component. The variation is derived from a version of the component, and inherits property values from the version and also from its ancestors, if applicable. To reuse the component, the reuse may be derived from the variation, in which case the reuse inherits the overridden property values through the variation, provided the variation is turned on, and through the version from which the variation was derived if the variation is turned off. A particular variation may be turned on and off within an inheritance chain.

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

Abstract: The system and method provide for software design and development that result in applications that are service-oriented. The systems provide for architecture development, integration, and maintenance using an SOA approach, and in particular an approach that provides for service-oriented development of applications (SODA). Such systems include numerous beneficial and advantageous features, including ways to define requirements and ways to design and develop applications.

Abstract: An object-oriented query to retrieve data from a data source stored on a data storage device connected to a computer is processed. One implementation involves receiving a Java Query Language (JQL) user query, compiling the JQL query using a Java compliant compiler, and detecting any compilation error due to a syntax error in the JQL query. If a compilation error is detected, then informing the user of the compilation error such that the user may correct the syntax error in the JQL query. Otherwise if a compilation error is not detected, then processing the JQL query for execution.

Abstract: According to some embodiments, Application Programming Interface (API) source code, including command design patterns, is determined to be executed as a runtime scenario. Class may then be automatically generated as linkable building blocks in accordance with the API source code and command design patterns. For example, API command classes and associated methods may be dynamically read using reflection, and a building block class associated with each API command class may be generated. Runtime readable embedded metadata may be planted in the building block classes, at least some of the metadata being provided by the reflection. According to some embodiments, a logical sequence of the building blocks classes may be linked in accordance with the runtime scenario.

Abstract: In an embodiment, a feature is an aspect of a class which represents information, data, behaviors, or capabilities encapsulated by the class. An accessing class may be given access to one or more specified features encapsulated by an accessed class, without gaining access to other features encapsulated by the accessed class. Accordingly, special access may be granted only to the behavior and data specifically designed for the accessing class, without allowing the accessing class access to all private data and behaviors of the accessed class, and without allowing all classes in a package access to the accessed class.

Abstract: A method, computer program product, and system for automating a test environment is provided. The method may include providing, at one or more computing devices, a superclass and a class-under-test, the superclass and the class-under-test having an inheritance chain therebetween. The method may further include inserting, via the computing device, an intermediate mock class between the superclass and the class-under-test. The method may also include automatically modifying, via the computing device, the class-under-test at runtime.

Abstract: A tool, such as a compiler or an interpreter, receives program source code and determines that the code includes an operation for which type conversion is permitted on an operand. The tool determines a source type of the operand, and a target type to which the operand is to be converted. In response to determining that the source type is a reference type and the target type is a primitive type, the tool generates a set of instructions to (a) determine whether, at run time, in accordance with a class definition of the reference type, a value of the target primitive type can be obtained via one or more method invocations on the operand (b) if such a value can be obtained, obtain the value and assign the value to a result of the operation and (c) if such a value cannot be obtained, generate an error indication.

Abstract: Systems and methods are provided for enabling communication between two systems using different commands, variables, protocols, methods, or instructions. In an embodiment, exit points in a software application may be used to insert additional code without altering the source code. In an embodiment, this additional code may interface with a backend abstraction layer, which may contain an itemization of functions to performed on external systems or data. In an embodiment, the abstraction layer may interface with a connectivity layer. In an embodiment, the connectivity layer may include instructions in a format recognized by the external system that correspond to the desired function in the backend abstraction layer that is to be executed at the external system.

Abstract: A system for generating a plurality of surveillance and compliance scenarios includes a first user interface comprising a graphical modeling tool for writing fraud detection logic in a first language and a second user interface for creating one or more configurable threshold parameters, one or more general parameters, as well as one or more configurable subsets of filters to be applied to the detection logic. The system is configured to interpret the fraud detection logic in the first language and translate the fraud detection logic into a second language that is capable of performing the fraud detection on a subset of transactions data after application of the one or more configurable subsets of filters to the detection logic, as well as limiting a number of alerts that can be generated after application of the threshold and general parameters.

Abstract: A system and method is provided for generating a RESTful communication service which offers REST2REST functionality seamlessly with automatic support for the API agnostic features such as policy enforcement, load balancing, routing, failover, logging, accounting, format conversion (XML2JSON,JSON2XML) etc. Such a system can include one or more applications, executing on one or more application servers. The system can also include a WADL plug-in which generates code for the RESTful communication service from Web Application Description Language files (WADL) which define the service interface and internal templates which define the code logic. The method offers rapid and efficient generation of REST APIs supporting API agnostic features, automatic REST API code generation from WADL files, and translation from WADL to WSDL.

Abstract: A system and method for improving software maintainability, performance, and/or security by associating a unique marker to each software code-block; the system comprising of a plurality of processors, a plurality of code-blocks, and a marker associated with each code-block. The system may also include a special hardware register (code-block marker hardware register) in each processor for identifying the markers of the code-blocks executed by the processor, without changing any of the plurality of code-blocks.

Abstract: Determining a class of an object is disclosed. A pointer of the object is obtained. One or more bits that are not implemented as address bits are extracted from the pointer. The one or more bits are interpreted as an identifier of the class of the object. The class of the object is determined to correspond to the identifier.

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

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

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

Abstract: Systems and methods for interfacing with hardware components using object oriented programming are disclosed. In some examples, system includes processing hardware unit. System includes multiple first level hardware components, each first level hardware component being coupled with processing hardware unit. System includes multiple second level hardware components, each second level hardware component being coupled with at least one first level hardware component. System includes memory, accessible to processing hardware unit. Memory includes compiler for object oriented programming language. Memory includes first and multiple second objects in object oriented programming language. Each of first or second objects mirrors first or second level hardware component, respectively. Each of first or second objects includes representation of feature or functionality of first or second level hardware component and code for communicating with first or second level hardware component.

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

Abstract: Handling a virtual method call includes extracting, from a pointer to an object, an identifier associated with the class of the object, the pointer to the object being associated with the virtual method call, and the identifier being embedded within the pointer; using the identifier to obtain a virtual method table, including locating a first entry in a class identifier table mapping a plurality of class identifiers to a corresponding plurality of class data, the first entry being associated with the identifier and comprising the virtual method table or a pointer used to obtain the virtual method table; locating a second entry in the virtual method table, the second entry being associated with the virtual method call; and jumping to an address associated with the second entry to execute code at the address.

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

Abstract: A method for generating script in a computer system having a user interface includes performing user actions by a user using the user interface to perform a user task, monitoring the user actions by the computer system, determining environment information in accordance with the user actions to provide determined environment information, and generating script in accordance with the user actions and the determined environment information to provide generated script. Storing the generated script and repeating the user actions in accordance with the stored script are provided. The user task includes configuring an application program and configuring a further application program in accordance with the generated script. The environment information includes configuration information and an identification of an operating system. The user actions further include providing user input data, updating a data object, and creating a system resource. The script is generated in accordance with context information.

Abstract: An update handler may determine object change data characterizing changes made to software objects. A change data manager store the object change data in a tracking database in conjunction with an object identifier for each changed software object. A query handler may receive an object-specific query requesting a subset of the object change data, and a response generator may provide the subset of the object change data from the tracking database, based on the corresponding object identifiers.

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

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

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

Abstract: A compiler receives source code for a program and determines that the code includes a declaration expression and an initialization expression in an assignment context. The declaration expression introduces a variable and specifies part of a parameterized type for the variable but not another part of the parameterized type. A parameterized type may include a ground type part and one or more type arguments; in a declaration expression, the specified part of the parameterized type may include a ground type and the unspecified part may include one or more of the type arguments. The initialization expression specifies an initial value for the variable, where the value has a parameterized type. The assignment context associates the declared variable with the initial value. The compiler infers the type for the variable based at least on the part specified in the declaration expression and on the type specified by the initialization expression.

Abstract: Various embodiments are directed to systems and methods for optimizing energy use with one or more optimization engine objects. An optimization engine object may have a plurality of dependent objects including at least a dependent optimization engine object, or at least one of a supply-side or demand-side object. The optimization engine object may receive dependent object attribute data from each of the at least one dependent objects; determine an optimal configuration for the plurality of dependent objects over the first time period subject to at least one optimization constraint; and conditioned upon the optimization engine depending from a superior optimization engine, transmit a net energy usage associated with the optimal configuration to the superior optimization engine.

Abstract: A method, computer program product, and system for automating a test environment is provided. The method may include providing, at one or more computing devices, a superclass and a class-under-test, the superclass and the class-under-test having an inheritance chain therebetween. The method may further include inserting, via the computing device, an intermediate mock class between the superclass and the class-under-test. The method may also include automatically modifying, via the computing device, the class-under-test at runtime.

Abstract: Systems and methods are provided for using monads to facilitate complex computation tasks in a cloud computing environment. In particular, monads can be employed to facilitate creation and execution of data mining jobs for large data sets. Monads can allow for improved error handling for complex computation tasks. Monads can also facilitate identification of opportunities for improving the efficiency of complex computations.

Abstract: An integrated software development system including an interface description language adapted to specify constraints on input parameters, a program analyzer adapted to identify input parameters of a software program, and a validation enforcement system adapted to enforce that an interface description in the interface description language complying with a predefined set of validation rules is provided for the input parameters of the software program.

Abstract: A method of detecting portions of code of a computer program that protect resources of a computer system unnecessarily can include identifying threads and synchronization objects that are used by a computer program during execution, determining the number of threads that have accessed each resource while it has been consistently protected by a particular synchronization object, and indicating whether the resource is suited for protection according to the number of threads that have accessed the resource.

Abstract: A method, apparatus and computer program product are provided for generating infrastructure code. In the context of a method, an ontology representative of a semantic data model is received. The method then processes the ontology in accordance with configuration information that defines the portion of the ontology to process, mapping information that defines a relationship between type information in the semantic data model and data types in the infrastructure code and one or more rules from the semantic data model relating to a conversion between different versions of semantic data model. In response to the processing, the method also automatically generates the infrastructure code in each of a plurality of computer languages.

Abstract: A mechanism for using stream objects in stream processing operations is provided. A definition of a class of stream objects used in stream processing algorithms can define output and update operations included in instances of the stream objects and the API (application programming interface) through which they may be called. The class definition may further include the type of state information to be held by the instantiated stream objects. An instance of the stream object may be instantiated in a text-based computing environment and the operations may be used to process streams of data.

Abstract: In an embodiment, a data processing method comprises receiving, from a first computer, and storing at a service provider computer, a copy of a non-natively-executable computer program; generating and distributing a download link that is configured, when activated, to cause downloading of a dynamically generated natively executable installer program from the service provider computer; receiving a request based upon the download link, and in response, the service provider computer generating a natively executable installer program that comprises the non-natively-executable computer program file and, optionally a player or other support software and/or one or more bundled external software offers, and providing the installer program to the end user computer; receiving, from the installer program, a request for the non-natively-executable computer program; providing the non-natively-executable computer program from the service provider computer to the end user computer; and the method is performed by one or more

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

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

Abstract: An object-oriented design program provides is configured to instantly render in a three-dimensional interface user CAD designs received as CAD-based design elements (e.g., CAD blocks or lines). The object-oriented program renders the user CAD designs regardless of whether the user designs are practical, or use finishes or colors that are in-stock for the selected design elements. In addition, the object-oriented program can also create intelligent software objects for the CAD-based elements at a later time, upon request by the user. The intelligent software objects can be configured to automatically resolve themselves in view of one or more system limitations and rules in related components, and to replicate any such resolution back to the CAD-based blocks if desired. Thus, a user can have the benefits of instant 3D rendering of CAD drawings with or without the automatic resolution provided by intelligent software objects, depending on the situation.

Abstract: An efficient, logical and expressive type system supports the combination of refinement types and type membership expressions, as well as a top type that encompasses all valid values as members. A bidirectional type checking algorithm is provided for the type system including synthesis and checking steps to statically verify types of code based on the type system.

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

Abstract: In one embodiment the invention provides a method to provide command line utility output to an application without the need of temporary files. The method includes receiving an identifier, receiving output from a command line utility, and storing the command line utility output in a system storage at a location identified by the identifier. In one illustrative embodiment, command line utility output is stored in a system registry database. In another illustrative embodiment, command line utility output is stored in a shared system memory. The method may be stored in any media that is readable and executable by a computer system.

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

Abstract: A user experience (“UX”) customization framework is provided that enables the customization of the UX provided by an operating system (“OS”) and application programs executing on the OS. The UX customization framework includes a UX platform engine that processes UX markup language files to create a customized UX. UX markup language files include data that is formatted according to a UX markup language. The UX markup language is a superset of the hypertext markup language that defines additional markup language tags for use in creating a customized UX, such as tags through which the functionality provided by an OS component or an application program that is exposed through an application programming interface may be utilized within the UX.

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

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

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

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

Abstract: A preparser tool is provided for converting Software Communications Architecture (SCA) Extensible Markup Language (XML) files into Common Object Request Broker Architecture (CORBA) structures usable by an SCA Core Framework (CF) and comprises a CF_PreParsers interface definition language (IDL) and a first preparser. The CF_IDL is configured to be in operable communication with an XML parser and with at least a first type of preparser. The first type of preparser is in operable communication with the CF_PreParsers IDL, is associated with a first type of descriptor for the CF, and is configured to call the XML parser to request parsing of a first set of first XML files, convert the first parsed set of first XML files into a first CORBA structure type, encode the first CORBA structure type into a first CORBA Common Data Representation (CDR) file; and write the first CORBA CDR file as a first octet sequence.

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

Abstract: A multi-dimensional information access capability, WorldSpace, within a Global Information Network Architecture (GINA) can create a user-definable environment for managing information access within the GINA object-oriented, software-based modeling environment for the modeling of various data sources and allowing queries and transactions across those sources. The modeling environment is described in itself, and is used to describe the model for information access. GINA WorldSpace allows different users to have different views of data sources depending upon their WorldSpace definition, which controls a user's view of the data source. The WorldSpace definition can use the attributes that makes the user unique and map them through GINA vectors to the characteristics of information to which the user has access. Attributes can include username, roles, language, locale, organization, and/or others. WorldSpace views can also impact the behavior of the data sources.

Abstract: A method and apparatus for converting a function call to a method call. In one embodiment, the method comprises receiving a call on a method and determining whether the call is an object method call. In response to a determination that the call is not the object method call, the method comprises instantiating a new object to convert the call into the object method call.