Embodiments of the invention generally provide a method, article of manufacture, and apparatus for code transformation. In one embodiment, the invention provides a method of transforming source code. The method determines if a source code statement includes a first operation that receives input from a result of a second operation, where the second operation acts on a plurality of arguments. If the source code includes the first operation, then the method transforms the source code into a plurality of statements that include the first operation acting on one of the arguments.

A distributed computer-implemented building automation system for supporting applications that interact with building automation devices. The building automation system has a first device and a second device interconnected across a network channel. A common object superclass stored in a computer readable memory defines a plurality of common objects through instantiation such that the common objects have attributes for storing data and have methods for processing stored data. A source object residing on the first device performs a first control method such that a first attribute of the source object is changed. A destination object residing on the second device performs a second control method using the first attribute of the source object. A surrogate object connected between the source object and the destination object has a value for the first attribute and represents the source object on the second device. The second object has access to the value of the first attribute for performing the second method.

Reduction of object creation during string concatenation and like operations that utilize temporary data storage during translating a first computer program into a second computer program in which program code is generated to utilize a reusable temporary object in the performance of multiple operations that require the use of temporary storage, e.g., string concatenation operations. As such, the reusable temporary object need only be allocated once, in contrast with conventional implementations where multiple temporary objects would otherwise need to be allocated in the performance of such operations. Consequently, the additional overhead associated with allocating memory for additional objects, as well as collecting such objects once they are no longer in use, is eliminated, thereby improving overall performance while handling such multiple operations.

A method and apparatus for managing a run-time environment is provided for improving performance and scalability of networked computer systems. In one example of the invention, a method starts by loading a class file, the class file specifying a class that includes a static class variable and a static initializer to initialize the static class variable. The static initializer is then invoked to initialize the static class variable. The class and the initialized static class variable are then saved in a second class file. The second class file is then loaded into a shared memory, the second class file including the class and the initialized static class variable.

Embodiments of the present invention are directed to a method and apparatus for extending a program element in a dynamically typed programming language. In one embodiment, a program element is extended without altering the source code defining the program element. An extend structure is used to extend a program element in a particular program. In one embodiment, the program element is a function. The function is extended by adding code to be executed by the function. In another embodiment, the program element is an enumeration. The enumeration is extend by adding additional constants to the enumeration. In another embodiment, the program element is a class. In one embodiment, a class is extended by adding code to the constructor of the class. In another embodiment, a class is extended by adding member variables to the class. In yet another embodiment, a class is extended by adding member functions to the class.