Abstract: A mobile electronic device with fragmented device settings enables preservation of user-defined settings during over-air software updates. Such a device in one aspect comprises a memory adapted to store at least one device setting including a default setting determined independent of any user of the device and a user setting determinable by a user of the device; a wireless interface adapted to receive a software update; and a processor communicatively coupled to the wireless interface and the memory and adapted to update the default-setting in response to the software update.

Abstract: Configurable levels of source control for the configuration of a process automation system are enabled through a preference selection or license. A user that starts with a certain level of source control may later change the level. Manually entered version information is overwritten if the user starts with a basic source control system after using a manual source control system. In the basic source control system, the increment of the version number is based on the significance of the change, where a parameter change in an existing function block is minor. When the user upgrades to full source control, the existing version numbers are maintained and the automated increment is based on the significance of the change determined by the user.

Abstract: A method for adding comments to deleted code includes maintaining a first version of a file in a code repository, providing the first version of a file available to a first user, receiving a second version of the file, the second version being an updated version of the first version of a file, the second version of the file including at least one segment of deleted code and at least one comment regarding the at least one segment of deleted code, simultaneously maintaining the second version of the file and the first version of the file in the code repository, providing the second version of the file to a second user, providing a comparison tool for comparing the first version of the file to the second version of the file, and receiving a modification approval indication including an approval of deletion of the at least one deleted segment.

Abstract: A method and apparatus for providing file system operation locks at a database server is provided. A database server may employ database locks and file system operation locks in servicing requests from consistent requestors and inconsistent requesters. A database lock is a lock that is obtained in response to performing a database operation, and the database lock is released when the database operation has successfully completed. A file system operation lock is a lock that is obtained in response to performing an OPEN file system operation, and the file system operation lock is released when a CLOSE file system operation is performed. The database server may use a temporary copy of the resource, which reflects all the current changes that have been made to the resource by database operations, in servicing consistent requestors, and may use the original version of the resource in servicing inconsistent requesters.

Abstract: Methods and apparatus, including computer program products, for storing and using customization data. A repository contains one or more repository objects, one or more variants for each repository object, and one or more layers for each variant. Each repository object has one or more model entities. The variants for each repository object are arranged in a first hierarchy, and the layers for each variant are arranged in a second hierarchy. Each layer includes a set of customization values, each customization value corresponding to one of the model entities. Customization values can be (but need not be) provided for each model entity in each layer and in each variant. The variants and layers can be arranged in order of specificity. A customization value for a model entity can be retrieved by locating the most specific variant and the most specific layer that contains a customization value for the model entity.

Abstract: Various embodiments of a method, system and article of manufacture provide a version number. An object has a present name and a present version number. In response to changing the present name of the object to a different name, the different name having been used by one or more other objects, one or more values of one or more first components of one or more other version numbers associated with the one or more other objects, respectively, are identified. An other version number is generated wherein a value of the first component of the other version number is different from the one or more values of the one or more first components.

Abstract: A versioning system and a versioning scheme verify compatibility between a plurality of entities. The versioning scheme comprises two version numbers—model version number and code version number. Model version number and code version number of each entity is maintained to determine the compatibility between a plurality of entities at the design level and the source code level. A layered structure of a software configuration management tool handles the versioning scheme of the plurality of entities.

Abstract: Embodiments of the present invention address deficiencies of the art in respect to defect classification for software development and provide a method, system and computer program product for automated defect classification in a software development tool. In an embodiment of the invention, a defect classification method can be provided. The method can include computing differences between versions of a line of source code, lexically analyzing the computed differences to produce a lexical construct, mapping the lexical construct to a classification, and assigning the defect classification to the line of source code.

Abstract: A method implemented within a distributed build system is described comprising: transmitting a first source file from a program build file repository to a first node, the first node using the source file to generate a target file identified in the build process; receiving a request for the first source file from a second node; and redirecting the second node to retrieve the first source file from the first node rather than from the program build file repository.

Abstract: Java class information is analyzed to determine if the code is standard for its particular class, and thus belongs to impliedly trustworthy software. An analysis tool performs a pre-analysis to train itself on standard class data for standard implementations of the object type and non-standard class data for non-standard implementations of the object type, and then performs a dynamic analysis of a received Java program to determine if its class data matches the criteria for a standard implementation of the object class.

Abstract: A software development environment exposes a GUI with visual markings for differentiating developer modifications to software files. The differentiation techniques can be provided as defaults with embodiments of the invention, or can be customizable to allow for useful grouping of modifications. The software development environment may also provide a selection tool for accepting, rejecting, or further modifying previous file modifications. A history of modifications may be maintained in the event that a developer needs to re-implement modifications that have been removed or distorted. A navigation tool facilitates analysis of modifications.

Abstract: Methods and apparatus for configuring process, environmental, industrial and other control systems generate and/or utilize models representing configurations of control systems and/or the systems controlled by them. Records of changes to the models or the configurations represented by them are maintained, thereby, for example, providing bases for determining current states, prior states and histories of changes. Objects in the model have characteristics, such as an object type characteristic and an area characteristic. Users can have corresponding permissions. A security mechanism apparatus controls access by users to the objects. Composite objects are defined by definition objects and are displayed in encapsulated or expanded formats. Objects can include an edit control type identifier that determines how they are presented for editing. Functionality responds to user commands by transferring characteristics of a first object depicted by the graphical user interface to a second object.

Abstract: A client stores client metadata entries corresponding to a plurality of data objects. During a first phase of a synchronization process, the client sends one or more client metadata entries to a server. Each client metadata entry sent corresponds to a data object for which at least one metadata parameter has changed since a prior execution of the synchronization process. During a second phase of the synchronization process, the client receives from the server one or more server metadata entries, each having at least one parameter that has changed since a prior execution of the synchronization process. The client identifies any received server metadata entry that conflicts with a corresponding client metadata entry, requests a user to select from among a predefined set of conflict resolutions to resolve the conflict, and the performs an action in accordance with the conflict resolution selected by the user.

Abstract: A system and method may be used to track software changes by analyzing intermediate language level representations of the software. For example, software changes may be tracked by analyzing object-oriented program code that includes one or more non-native binary executables based on an intermediate language. The program code may be associated with metadata describing content of the non-native binary executables. An object tree, which includes a plurality of nodes, may be constructed to represent the non-native binary executables and the metadata describing the content of the non-native binary executables. One or more of the plurality of nodes may be hashed to associate respective digest values with the hashed nodes, such that changes in the received program code can be tracked using the digest values associated with the hashed nodes.

Abstract: A method of packaging a dynamically linked computer program function comprising: establishing an attribute, each attribute exhibiting a plurality of at least one of variations, characteristics and parameters associated with the dynamically linked computer program function; obtaining a source file associated with the dynamically linked computer program function; and compiling and linking the source file iteratively to create a single executable file based on the at least one of variations, characteristics, and parameters for each attribute. The single executable file is configured to facilitate choice of a selected version of the function based on a particular at least one of variations, characteristics, and parameters for each attribute.

Abstract: A subsystem provides for negotiating a common version for interfaces of objects supported by the subsystem and a remote subsystem. In one embodiment, the subsystem determines a list of interfaces, including a version range for each interface, of objects supported by the subsystem, and a list of interfaces, including a version range for reach interface, of objects supported by the remote subsystem. The subsystem then negotiates a list of a version of each interface supported by both the subsystem and the remote subsystem by matching the versions for each interface and selecting the highest version that is common to both the list of interfaces of objects supported by the subsystem and the list of interfaces of objects supported by the remote subsystem.

Abstract: A switched file system, also termed a file switch, is logically positioned between client computers and file servers in a computer network. The file switch distributes user files among multiple file servers using aggregated file, transaction and directory mechanisms. The file switch distributes and aggregates the client data files in accordance with a predetermined set of aggregation rules. Each rule can be modified independently of the other rules. Different aggregation rules can be used for different types of files, thereby adapting the characteristics of the switched file system to the intended use and to the expected or historical access patterns for different data files.

Abstract: Described is a system and method that separates a managed code runtime library or program into four parts, comprising a header, resources, metadata and method implementations. The metadata and some or all of the resources are maintained in system memory (RAM) the entire time that the program is running. The method implementations and any non-maintained resources are loaded on demand, and then discarded such as via garbage collection. The amount of memory consumed by a managed code program is thus reduced relative to non-separated environments, but because the metadata and selected resources are in memory, the program execution is highly efficient due to significantly reduced access of data in non-volatile storage. The parts of the assembly that are maintained in RAM can be saved as code library files, providing shared use by programs and efficient loading by eliminating any need to again parse a program to identify the separate parts.

Abstract: Computer-based systems, methods and software products for monitoring software application quality comprise enabling a computer to generate a developer-identifying output identifying which software application developer (301) among a plurality of software application developers is responsible for a given software application modification in a corpus of software application code; analyzing the corpus of software application code to generate a software code quality output comprising values (303-305) for metrics of software code quality; and correlating the developer-identifying output and the software code quality output (306) to produce human-perceptible software application quality reports (309) on a per-developer basis, thereby to provide attribution of quality metric values on a per-developer basis.

Abstract: A blueprint is described that provides a framework for writing a code generator. A blueprint translator translates the blueprint into one or more classes with source code. The newly generated code can then be compiled. If the user wishes to add additional functionality to a generated class, this is done in a separate source file. At compilation time, the compiler combines the generated class with the user's additions, as if they were written in a single class. Later, if the blueprint is ever changed, the generated code can safely be updated without overwriting the user's additions. Alternately, the user can embed his desired additions or changes directly into the blueprint (embedded code). In this manner, should the blueprint ever be re-compiled, the user's changes will still be present. The partial classes technique can be used in conjunction with the embedded code technique.

Abstract: A computer platform operating system compatibility management method and system is proposed, which is designed for use in conjunction with a computer platform, such as a network server, for the computer platform to be selectively bootable between an old-version operating system (such as Windows NT4.0) and a new-version operating system (such as Windows Server 2003 or Windows 2000). This feature allows the customer to selectively install either an old-version operating system or an new-version operating system successfully onto the server, and allow both old-version operating system and new-version operating system to be compatible with the hardware of the server.

Abstract: Systems and methods for extending a directory schema independent of schema modification are described. In one aspect, a directory schema data structure includes a flexible attribute data field. The flexible attribute data field identifies a complex data type. The complex data type is used to express one or more operational or data providing properties of a flexible attribute. The one or more operational or data providing properties are independent of the complex data type and independent of directory schema modification. The directory schema data structure also includes a flexible structural object content class to encapsulate the flexible attribute.

Abstract: A method for extracting requirements of an architectural software model comprises providing a use case model as a directed graph of the architectural software model comprising nodes corresponding to use cases and relations between nodes, and creating, automatically, a tree comprising a root node corresponding to an abstract use case and at least one leaf node corresponding to one of an abstract use case and a concrete use case.

Abstract: The present invention relates to a system and methodology to facilitate software development activities via the concept of “Shelving” which provides an improved alternative to conventional branching technologies in certain scenarios. In one aspect, a software development system is provided. The system includes a shelving component that captures a current state of an intermediate software design. A version control component processes the intermediate design as if the intermediate design were a completed software design.

Abstract: Method and system for managing development objects for computer program code. One development object comprises source code written in a positional language while the other development object comprises a document object model (DOM) that corresponds to the source code. The two development objects are synchronized using a set of synchronizer objects. In particular, the various character ranges defined by the positional language are used to efficiently map a portion of the source code to a corresponding portion of the DOM. As a result, a synchronizer object can readily update a development object with a modification received for the other development object.

Abstract: A method is provided for synchronization of a first workspace with a second workspace. Both workspaces are connected to a version control system. The method comprises for a first refactoring operation being performed on the first workspace, performing first refactoring step, resulting in a modification of an object, storing the modification in a change information for the object, storing in a change information recording step the change information, and storing in a descriptor recording step refactoring information comprising information enabling execution of a refactoring corresponding to the first refactoring step during an update operation. The method further comprises for a commit operation, delivering in a change information delivery step the change information to the version control system, and delivering in a descriptor commit step the refactoring information to the version control system.

Abstract: A development and build environment creates information used by the master node and nodes in a network of nodes to perform software loading and evaluation during boot and normal runtime. The invention creates metadata and dependency data for packages and modules. Module metadata are created and inserted into the package that includes information such as the module's: binary signature, name, directory path, characteristics, and API dependency information. Packages are formed based on features/characteristics or purpose. A package contains one or more modules. Metadata are created for each package and inserted into the package that includes information such as the package's: name, build date, and characteristics.

Abstract: A method, computer program product, and data processing system for exchanging information regarding software source code among a team of developers is disclosed. In a preferred embodiment of the present invention, a developer associates commentary with a particular code feature, such as a function or object class. A list of intended recipients or readers of the commentary is obtained from the developer. Additional settings regarding such things as an expiration date for the commentary are also obtained from the developer. The source code with associated commentary is then made available to the intended readers. If desired, the source code with associated commentary may be transmitted the intended recipients via e-mail or an “instant message” or other form of notification can be transmitted to the intended recipients to notify them of the commentary to be read.

Abstract: An apparatus, program product and method generate difference data representative of modifications made to one release of a standard code base to facilitate the adaptation of later releases of the standard code base. The difference data is generated at least in part in connection with canonical parsing of a modified version of a release of a standard code base such that the difference data is representative of semantic changes made in the modified version.

Abstract: Described herein is at least one implementation employing multiple self-describing software artifacts persisted on one or more computer-storage media of a software-based computer. In this implementation, each artifact is representative of at least part of the software components (e.g., load modules, processes, applications, and operating system components) of the computing system and each artifact is described by at least one associated “manifest,” which include metadata declarative descriptions of the associated artifact.

Abstract: A shared memory technology where shared objects can be used by any of multiple users, applications, or program sessions with programming language support during development and at runtime. The developer can declare shared memory behaviors at design time to cause one or more area classes to be generated for use at runtime. A shared objects memory is managed by the runtime environment. Content is stored at runtime in an area instance of an area class. Class methods to be generated that include methods for attaching and detaching a running session to and from an area instance, and for detaching a session from a change request on an area instance with a commit or a rollback. The runtime environment manages locks for area instances. There are programming language constructs for creating area instances and for creating data objects of arbitrary data type within area instances.

Abstract: Database item versioning, such as items like stored procedures found in databases such as Standard Query Language (SQL) databases. In one embodiment, a program such as an editor, a database, a source and a mechanism. An editor program provides for editing a stored procedure. The databases includes the stored procedure. The SCC system stores versions of the stored procedure. The mechanism checks in and checks out the stored procedure to provide for effective versioning thereof.

Abstract: A system for managing software builds is provided. The system comprises a code control system operable to maintain a code version and a information associated with the code version, a parser module in communication with the code control system, the parser module operable to parse the information associated with the code version and create a change report, and a compiler module in communication with the code control system and operable to compile the code version into an object version based on the change report. A method of managing software builds is also provided. A method for building a software version is also provided.

Abstract: An interface is provided between a running computer application and a system monitor. The system monitor handles notification messages generated by the computer application. The interface includes an import module to scan a source file, extract notification messages from the source file and store the notification messages in a scan file. The interface includes a manager module to display each notification message in the scan file in a table in a graphical user interface to allow modifications to the data in the table. The data is exported to an export stage. The export module performs any translation required to create a file of the notification messages in a format that is acceptable to the system monitor.

Abstract: An apparatus for identifying a contextual change to a source code file, in a development environment, the apparatus including: a detector component for detecting a modification to the source code file; a requester component for retrieving a previous version of the modified source code file; a parser component for parsing a first source code set associated with the source code file and a second source code set associated with the previous version of the source code file and for building an in-memory representation of the first and second source code sets; and a comparator component for comparing the in-memory representation of the first source code set with the in-memory representation of the second source code set in order to generate contextual information identifying a change made to a source code element associated with the modified source code set.

Abstract: A computer-implementable method, system and computer media for auto-generating and auto-versioning a dynamic document are presented. In a preferred embodiment, the computer-implementable method includes populating a dynamic document with content from multiple sources. The dynamic document is then version named in accordance with a nomenclature rule that identifies a source and version of content from the multiple sources. In response to a content from one or more of the multiple sources changing at a source, the dynamic document is updated with updated content, and a version name of the dynamic document is updated to reflect the updated content.

Abstract: Techniques for gathering and tracking build information are described. Builds are registered initially. When a test execution is performed, a matching build is automatically determined from those previously registered builds as matching the software under test for a particular session. This information is tabulated in a database in accordance with additional software and hardware or platform information describes the environment in which a program executes. The platform information includes software component information and system configuration information uniquely identifying a particular instance of an environment. Data stored in the database is then analyzed and available for performing queries, for example, such as regarding code volatility and determining testing associated with a particular build.

Abstract: A system and method for receiving an origin file corresponding to source code, modifying the source code to create a modified source code, creating a modified file corresponding to the modified source code and comparing the modified file to the origin file. A system having an editor for editing source code to create a modified source code and a patch aware editor storing an origin file corresponding to the source code and creating a modified file corresponding to the modified source code, the patch aware editor comparing the origin file to the modified file and displaying conflicts between the files.

Abstract: A method and apparatus for a guided procedure development and testing for computer code. An embodiment of a method includes receiving a component for a software program, and storing the component in an inactive state. A new version of the software program is built, the new version being limited to the component stored in the inactive state and one or more components of the software program that are in an active state, with the new version being built in the inactive state. If the building of the new version is successful, then the new version of the software program is tested. If the testing of the new version is successful, then the component is moved into the active state.

Abstract: Embodiments of the present invention provide a way to accurately track and audit the intellectual property aspects in software, such as packages or distributions of open source software. An intellectual property (IP) tool analyzes software as its source code is being submitted to a code repository or as a distribution of software is being built. The IP tool parses the source code and identifies various intellectual property aspects in the code, such as licenses, trademarks, patents, and the like. The IP tool then archives this information into a database and may also provide an output that indicates the results of this analysis. The analysis by the IP tool can be provided as meta-data with the software distribution or may be provided in the form of reports that are sorted and collated in various ways for the convenience of the user.

Abstract: An approach is provided for versioning of services and service contracts. According to the approach, when the executable code of a service external to one or more composite applications is generated, first version information is automatically stored in a contract that describes the service. The contract specifies an input interface and an output interface of the service. The first version information stored in the contract specifies a first executable version of the service. When the executable code of the service is re-generated, the first version information stored in the contract is automatically modified into second version information. The second version information specifies a second executable version of the service.

Abstract: A method and system of detecting vulnerabilities in source code. Source code is parsed into an intermediate representation. Models are derived for the code and the models are then analyzed in conjunction with pre-specified rules about the routines to determine if the routine call posses one or more of pre-selected vulnerabilities.

Abstract: The invention is directed to a method for a software provider to enable a software-acquiring entity to arrive from an existent first signed piece of code at a second signed piece of code. Both pieces of code were generated at the software provider by use of a first software archive generator under use of generation instructions. The software provider provides to the software-acquiring entity a difference code that comprises the steps necessary to arrive from the first signed piece of code at the second signed piece of code. The difference code is combinable at the software-acquiring entity with the first signed piece of code by a second software archive generator to generate the second signed piece of code. The second software archive generator is therefor to be fed with those generation instructions that were used by the first software archive generator for the generation of both pieces of code.

Abstract: For migrating a work flow in a workflow management system having at least one process instance executing an original process definition, each process instance is checked during the execution of the original process definition whether the process instance meets the migration condition. If the migration condition is met, the corresponding process instance is migrated to a modified process definition while executing the original definition.

Abstract: A distributed software application comprises a plurality of software components within a plurality of executables. A manager component for the distributed software application handles: an addition of one or more first resources to the distributed software application on behalf of the distributed software application and/or a removal of one or more second resources from the distributed software application on behalf of the distributed software application.

Abstract: Maintaining Multiple Valid Concurrent Serialized Object Versions Techniques are disclosed for concurrently maintaining serialized objects that were created from more than one version of a class definition. According to preferred embodiments, a component maps and enforces multiple valid stream-unique version identifiers (“SUIDs”) for a collection of class definitions (such as the classes of a software product that is undergoing change from one version to another). This component programmatically detects when an object's SUID value does not match the code attempting to deserialize the object, and then programmatically determines whether the object is compatible with the code even though the SUID values do not match. Preferably, this determination is made by consulting a stored mapping, in which the SUIDs of compatible versions have been recorded.

Abstract: The invention includes a method and apparatus for assessing an available version of a sourced element. The method includes obtaining a description of an available version of the sourced element, identifying a plurality of evaluation items for the sourced element by evaluating the description using at least one evaluation category including a plurality of evaluation parameters, and determining an overall assessment of the available version of the sourced element using the identified evaluation items for the sourced element. The overall assessment is indicative of a value associated with the available version of the sourced element. The method may further include generating overall assessments of other available versions of a sourced element or generating overall assessments of available versions of other sourced elements, and prioritizing the available versions of the sourced elements using the overall assessments of the available versions of the sourced elements.

Abstract: A system and method for creating and supporting multiple customized versions of a software application within a web-based environment is disclosed. Customized code is created for a user of the software application. This code is invoked by inserting code hooks such as subroutine calls into the software application. The file containing the customized code is moved to a respective physical directory created for the user. An association is then created between this physical directory and a virtual directory of the type supported by IIS and other similar web servers. Finally, the virtual directory and the customized code file are identified by a reference provided with the software application. When a run-time version of the code is generated for the user, this reference along with the association created between the virtual and physical directories result in generation of a user-specific version of the software application.

Abstract: A method for managing software life cycle is provided. The method provides a multi-user distributed environment supporting the proactive management of a software life-cycle for at least one stakeholder. The method includes the steps of: obtaining and analyzing requirement information, generating test plans, creating WBS documents, storing and managing life cycle historical information, supplying online workflow-based notifications and messages and providing role-based customized functionality.

Abstract: A user centric approach to program product distribution, such as a program product, including a complementary multi-vendor code control system (MVCCS) suitable for use to practice the user centric distribution approach is disclosed. Under the user centric approach, versioning control information of the source/object files of various program products to be installed on various user computer systems are maintained on a user computer system by user computer system basis. Each user computer system or its proxy is provided with a portion or an entire MVCCS to facilitate receipt and storage into a common repository for the user computer system versioning control information of different source/object files of different software vendors, and to facilitate retrieval of selective versions of the different source/object files for the user computer system using versioning control information stored in the common repository for the user computer system.