Abstract: Concepts and technologies are described herein for hash-based file comparison. In accordance with the concepts and technologies disclosed herein, a comparison tool is configured to compare hash values in a first hash list associated with a first file to hash values in a second hash list corresponding to a second file. The hash values are computed for functional blocks of the respective files and therefore can be compared to indicate if the functional blocks of the two files match one another. If the hash values match, the functional blocks associated with the respective hash values can be determined to match, while hash values that do not match can indicate that the corresponding functional blocks do not match one another.

Abstract: The present invention extends to methods, systems, and computer program products for changing addressing mode during code generation. Generally, embodiments of the invention use a compiler transformation to transform lower level code from one address alignment to another address alignment. The transformation can be based upon assumptions of a source programming language. Based on the assumptions, the transformation can eliminate arithmetic operations that compensate for different addressing alignment, resulting in more efficient code. Some particular embodiments use a compiler transformation to transform an Intermediate Representation (“IR”) from one-byte addressing alignment into multi-byte (e.g., four-byte) addressing alignment.

Abstract: A system that incorporates teachings of the present disclosure may include, for example, a computer-readable storage medium operating in a web server having computer instructions for receiving from an Internet browser a request to create a viewing profile for a web page, creating the viewing profile by generating an asynchronous script for processing at least a portion of data supplied by a web service, embedding the asynchronous script in the web page, and presenting at the Internet browser the updated web page with the embedded asynchronous script. Additional embodiments are disclosed.

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

Abstract: Compile-time optimized bounds checking of user-defined types is provided. A user-defined class has an annotated memory-accessing method, and an annotated bound-providing member such as an integer field containing a bound or a method that returns a bound when called. The user-defined-bounds check may supply bounds checking where the programming language has none, or it may supplement existing bounds checks, e.g., by wrapping a built-in array type or a garbage-collector-managed type. Bounds checking can be extended beyond arrays and other types whose layout is controlled by a compiler, allowing efficient systems programming in a managed code environment. A bounds-check representation is inserted by the compiler in intermediate language code. Optimization then reduces duplicative bounds checking.

Abstract: The present invention extends to methods, systems, and computer program products for assigning type parameters. Embodiments of the invention permit using a visual editor to edit arbitrary object instances in a graphical fashion. Instances of generic types can be manipulated to change the type parameters for that generic (to be able to change a List<Customer> to a List<Product>, for instance). Values are preserved and data can be patched to other dependent nodes in an object hierarchy.

Abstract: A computer-implemented method is disclosed for generating Dojo-conforming JavaScript Object Notation (JSON) objects for base objects of an object-oriented programming environment that have been annotated to denote which attribute declarations of the base object correspond to identified Dojo attributes. In a Java class, for example, annotations may be made to indicate which class attributes correspond to the identifier attribute of a Dojo JSON object and based on those annotations a Dojo-conforming JSON object may be generated.

Abstract: An inter-language interface is created for an executable file written in a legacy language. The header associated with the legacy file is initially marked up language to generate a first marked header. The legacy file is then wrapped with a first wrapper based at least partially upon the first marked header to create a first wrapped file. Additionally, the first marked header is associated with type maps customized in accordance with the target language in order to generate a second marked header. An executable file may then be generated by wrapping the first wrapped file with a second wrapper so as to be executable in the target language, thereby creating a second wrapped file. Additionally, an interface layer is generated to associate functions in the legacy language with methods in the target language and to define the usage in the target language of the parameters in the legacy language.

Abstract: In an embodiment, a technique for acquiring a class definition of a class, the class associated with an enumeration, the enumeration enumerating a partial list of instances of the class; generating a data structure based on the class definition, the data structure associating one or more identifiers with an instance enumerated in the enumeration; and storing the data structure in a computer storage.

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

Abstract: A computerized method for detecting errors in program code including searching for lines of command codes in the program code, wherein a line of command code includes a set of command codes and a set of indices; separating the sets of command codes from the sets of indices, wherein the sets of indices are a matrix; parsing the sets of command codes to locate three or more consecutive lines of command codes, which have the same sets of command codes; for the three or more consecutive lines of command codes, generating sets of vertical indices from vertically aligned indices in the matrix; determining if each set of vertical indices does not match at least one known series in a set of known series; and reporting to a user computer each set of vertical indices that does not match the at least one known series.

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

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

Abstract: A method and apparatus for converting a method call to a function call. In one embodiment, the method comprises receiving an argument list from a function that has been called by a subroutine call. The method further comprises determining whether the subroutine call is a method call from the argument list. In response to a determination that the subroutine call is the method call, the method comprises converting the method call into a function call.

Abstract: An aspect container being operable to generate an instance of itself at run time is provided. The aspect container comprises logic operable to create an instance of the aspect container by reading configuration information specifying a sequence of one or more aspects from an aspect container configuration file corresponding to the aspect container. The logic is also operable to generate instances of the aspects in the sequence, configure each aspect instance with its configuration information from an aspect configuration file corresponding to the aspect, and chain the aspect instances according to the specified sequence, such that the chain of aspect instances preamble and postamble activities of a class or method.

Abstract: An object-oriented scripting tool uses a XML file for software development and domain management. The XML file includes at least a first tag that defines a scripting class in an object-oriented scripting language. The scripting class includes at least one method, which is defined in a second tag in the XML file. A generic software development and domain management script can be encapsulated into a general scripting class, which can be extended into individual scripting class for specific software development and domain management task.

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

Abstract: Various technologies and techniques are disclosed for providing a common generic interface for numeric types in statically typed languages. The common generic interface defines basic arithmetic operations, thereby allowing basic arithmetic operations to be performed on the numeric types. The common generic interface provides support for overflow detection when a result of an operation being performed on a particular numeric type will result in an overflow situation when the operation does not fit within a range supported by the particular numeric types. The common generic interface provides support for one or more mathematical properties to be retrieved for a particular one of the numeric types being used in a particular circumstance.

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

Abstract: A registry for a service oriented architecture (SOA) comprising a plurality of processing objects. The registry may include a plurality of non-formalized operation requirements for the plurality of SOA objects, a plurality of technical assertions for the plurality of SOA objects, and a plurality of links, linking each non-formalized operation requirement to at least one technical assertion of the registry.

Abstract: Managing user interface characteristics in displaying data storage system information. New functionality may be provided that can effect look-and-feel skinning for OEM and client customization. Extensions to conventional Java Synth Look-and-Feel technology for support of OEM and client customization may be enabled. Multiple Synth XML files can be merged, e.g., on the fly, and form one Synth XML file. One primary Synth XML file may be provided and any Style elements defined in secondary XML files may override corresponding Style elements in the primary XML file. For example, an OEM customer can define one Button Style in a secondary (customer's) XML file, and this definition can be detected at runtime and overrides a primary XML file's Button Style, resulting in the OEM look and feel.

Abstract: Systems and methods that enhance expressibility in a programming language (e.g., Visual Basic) via relaxation of artificial restrictions and extension of delegates associated therewith, without changing the runtime infrastructure. A stub is employed that can replace an impermissible expression in the programming language, to leverage the existing permissible expressions.

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

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

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

Abstract: Memory management for object oriented applications during run time includes loading an object oriented application into a computer memory. The object oriented application includes a plurality of nodes in a classification tree, the nodes including key value pairs. The nodes are aggregated in the classification tree by a computer. The aggregating includes eliminating redundant keys and creating a composite node. The composite node is loaded into the computer memory. The plurality of nodes in the classification tree are removed from the computer memory in response to loading the composite node into the computer memory.

Abstract: The use of a data structure that is a symbolic representation of a keyed array that has an array variable and an associated key variable. There is a correlation maintained between the variable type of the array variable and the corresponding keying set that is to be bound to the associated key variable. The keyed array may remain unbound thereby being simply symbolically represented, or the keying set may be bound to the key variable more immediately. In one embodiment, once the keying set is bound to the key variable, data may be bound to the array variable itself. This may be repeated for multiple keyed arrays. The data from multiple keyed arrays may be operated upon to about another array of values, which may then be aggregated in some way.

Abstract: A method and an apparatus that execute executable codes to install a persistent object from a storage into an application server to access remote services in an EIS are described. The executable codes are based on relational properties for mapping an API (Application Programming Interface) function of an EIS to an object of a cross-platform connection framework coupling the EIS with the application server. The application server is enabled to access the API function of the EIS via the persistent object as part of the cross-platform connection framework.

Abstract: A method for extending a script language in a runtime environment of a data processing system to support an application, the runtime environment having a script language interpreter, the method comprising: subclassing a predetermined object defined by the script language to create a subclassed object, the predetermined object having an original method, the subclassed object having a respective replacement method for supporting the application; dynamically registering a symbol corresponding to the subclassed object; detecting the subclassed object in the application with the script language interpreter; and, executing the replacement method with the script language interpreter.

Abstract: A method for the generation of a source code for a computer program for the execution or simulation of a complex process in which a multiplicity of subjects communicate with one another. In this method, the processes are described, the description of the processes is stored in a process file, and with the aid of the process file a source code for a computer program is generated, with a separate source code file being generated for each subject. Through the provision of a source code file for each subject, a complex process may be easily and therefore automatically split into several sub-programs, the source code files, which may be generated automatically. In this way it is possible to generate automatically a computer program for a very complex process. A further benefit of the method according to the invention is that it may be executed after automatic generation, i.e. it may be validated by an execution immediately after generation.

Abstract: A computer method and system preserves derived union constraints and enforces the same in generated target code. The method includes (a) providing a model element having one or more derived union properties, (b) tracking derived union constraints from the derived union properties of the model element, and (c) interpreting the tracked derived union constraints and generating therefrom an implementation that enforces the derived union constraint. Tracking may be by annotating the model element accordingly.

Abstract: A computing device receives an object at runtime of a compiled application, wherein the object is a component of the application. The computing device generates a transactional proxy for the object, the transactional proxy including transactional logic, a transactional marker and a pointer to the object. The transactional proxy is passed to the application, wherein the application to make calls on the transactional proxy instead of on the object.

Abstract: Methods, systems, and software for providing or utilizing a software solutions bag of development components and enterprise knowledge—whether developed internally or by third parties—are described herein. One method for managing reusable development components comprises providing a catalog of a plurality of development components to a user. The cataloged development components may include or reference at least a first development component of a first type and a second development component of a second type. A software solutions bag is then generated based on a user selection of at least one of the cataloged development components.

Abstract: A system and method for ensuring consistency of data and preventing data races, including steps of: receiving and examining a computer program written in an object-oriented language; receiving sequences of accesses that form logical operations on a set of memory locations used by the program; receiving definitions of atomic sets of data from the memory locations, wherein said atomic sets are sets of data that indicate an existence of a consistency property without requiring the consistency property itself; inferring which code blocks of the computer program must be synchronized in order to prevent one or more data races in the computer program, wherein synchronization is inferred by determining by analysis for each unit of work, what atomic sets are read and written by the unit of work; and providing a message indicating where synchronization is required.

Abstract: Methods are classified as simple or complex. Complex methods are modified to add a tracer. Methods classified as simple are not modified to add a tracer. There are many different standards that can be used within the spirit of the present invention to classify methods as simple or complex. In one embodiment, a method is complex if it meets three criteria: (1) the method has an access level of public or package; (2) the method is non-synthetic and (3) the method calls at least one other method. Methods that do not satisfy all three criteria are classified as simple methods.

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

Abstract: A method includes receiving a modeling template, the modeling template comprising a plurality of modeling constructs and profile constructs, each profile construct generated from a modeling profile and comprising an extension of one of the modeling constructs. The method further includes parsing the modeling template into the plurality of modeling constructs and profile constructs. One or more object-oriented constructs are defined based, at least in part, on the parsed modeling constructs and profile constructs. Source code is automatically generated in an object-oriented programming language based, at least in part, on the defined object-oriented constructs. The object-oriented programming language comprises an object-oriented programming language with embedded inferencing.

Abstract: A software application to be used in an environment includes environmental, behavioral, design, and run-time model creating portions. The environmental portion includes a first set of attributes of the environment, wherein each of the first set of attributes has a declaration and a decomposition into environmental classes. The behavioral portion describes behavior of the software application at a boundary of the software application and the environment, wherein the behavioral model includes a second set of attributes, and each of the second set of attributes has at least one of a declaration and function. The design portion includes a first decomposition of the second set of attributes into a first plurality of groups. The run-time portion includes a second decomposition of the second set of attributes into a second plurality of groups, wherein the run-time model can record the decomposition of the software application into run-time components.

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

Abstract: One embodiment of the present invention provides a system that supports efficient access to object properties in a dynamic object-oriented programming language. During operation, the system receives a request to access a property for an object associated with a given map object. The system then determines a hash value using the given map object and a signature for the property, and uses the hash value to retrieve a code stub from a cache. Next, the system executes this code stub, which includes instructions that facilitate accessing the property, to access a memory field associated with the property.

Abstract: A compositional application programming interface (API) permits non-sequential construct declaration independent of other API calls. A wrapper is applied to an imperative API to provide a compositional interface that enables arbitrary and autonomous construct declaration. Additionally, a literal syntax (e.g., code literals, graphic literals . . . ) affords a convenient declaration mechanism for such constructs.

Abstract: An improved system and method is disclosed for making the Common Information Model (CIM), produced by the Distributed Management Task Force (DMTF), more flexible and extensible without requiring changes to it or its existing implementations. MultipleInheritance associations are implemented to define extension abstract classes for managed element information and to create static and dynamic add-in classes, all operable to reference the CIM schema class. Ambiguity is mitigated by not allowing properties of different data types to have the same name in super classes that are used for MultipleInheritance associations. Data integrity is facilitated by merging class properties of the same name and data type through the use of a Min algorithm. Concrete user classes are derived from new abstract classes such that management functionality is enabled for managed element properties.

Abstract: A layered architecture for a web service is provided with a data tier, object representation, data transformation, and a service tier. Scalability is achieved by relying on relatively high degree of decoupling, lightweight data interaction, and reducing overhead of transaction demands. Custom web services can be built on top and leverage the capabilities of the flexible framework including lightweight transaction support, event-based business logic extensibility, and efficient data contract binding.

Abstract: Architecture that extends existing types including constructed and sealed types using extension methods. Extension methods are static methods that can be invoked using instance method syntax. Extension methods are declared by specifying the keyword “this” as a modifier on the first parameter of the methods. Extension methods have all the capabilities of regular static methods. In addition, once imported, extension methods can be invoked using instance method syntax. Also disclosed are rules for importing extension methods, and extension method invocations. Extension methods are imported through using-namespace-directives. In addition to importing the types contained in a namespace, a using-namespace-directive imports all extension methods in all static classes in the namespace. In effect, imported extension methods appear as additional methods on the types that are given by their first parameter and have lower precedence than regular instance methods.

Abstract: A method of mapping a software installation, including: (a) providing a software installed on a computer with an operating system and at least one storage device, the installation including a plurality of software components and at least one entry in a system record on the storage device; (b) providing a plurality of potential interaction points between said installation and said computer; (c) executing at least one informer on said computer to obtain information about said potential interaction points of said installation with said operating system; and (d) determining a plurality of relationships between said components based on said interaction points on which information was obtained.

Abstract: A computer system has a runtime environment (e.g. Java) and a deployment unit (e.g. in a Spring framework layer) arranged to deploy the application into the runtime environment. The application comprises bundles (e.g. OSGi bundles) with manifest metadata having export statements defining exported packages. The deployment unit comprises a receiver unit to receive the bundles, an extractor unit to examine the metadata and extract the export statements, a converter unit to convert each of the export statements into a corresponding import statement, and a creator unit to add a synthetic bundle having the import statements inserted in its metadata. The deployment unit sets a thread context class loader to delegate class loading to a class loader of the synthetic bundle. Thus, at runtime, classes of the application are only loaded when they are explicitly exported packages as defined by the synthetic bundle.

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

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

Abstract: A broker-program generating unit generates a broker program by using an interface-definition-language file defining interface definition information concerning a plurality of applications described in various programming languages. The broker program is installed in a middleware platform that absorbs and hides a common object request broker architecture, and brokers an interaction between the applications with a structure that stores data in a binary format as an interface to the middleware platform.