Abstract: A computer method and apparatus for managing revisions to engineered products includes a repository, a local data store (working copy) and a revision manager. Each engineered product is formed of one or more assets. The repository holds the plurality of assets and tracks changes of the assets. For a given asset, the revision manager provides, together in a certain screen view, display of (a) indications of changes made to a working copy of the given asset relative to the given asset as held in the repository, and (b) indications of changes made to the given asset in the repository relative to the working copy of the given asset. The certain screen view in one embodiment employs a tabular format with sortable columns, color coded symbols, textual summaries of changes made to assets and textual description of changes made to assets in the repository.

Abstract: A system and method for tracking and notifying related software, modules, and configuration files during software development and maintenance. A database, software build programming, a software module tracker, requirements management tools, and software source code that includes a comments area are implemented in connection with user interfacing to provide the method.

Abstract: Installation of multiple servers with interdependencies is done in parallel steps, with each server advancing in sequence with other servers. When a second server is dependent on a first server during the installation process, the first server may finish a task and send a message to the second server to attempt an installation step that depends on the first server. If a problem occurs, the second server may revert to a configuration state before the attempted step and the first server may reattempt the installation step on which the second server depends.

Abstract: System and method for version string generation for artifacts in a repository is disclosed. A first source code management server manages first source code versions in a first repository and assigns a first source code version string to each first source code version. A first artifact repository comprises a first artifact built based on one of the first source code versions. A product manager generates a first artifact version string for the first artifact based on the first source code version string of the first source code version used to build the first artifact.

Abstract: Embodiments includes techniques for retrieving revisions in source code from a plurality of revision history data sets including link information to the source code and version information. The revision history data includes a function unit specified by a user is extracted from the plurality of revision history data sets, and a list of the extracted revision history data is displayed on the display device. Also, the display of this list includes displaying on the display device or creating in a storage area source code or information associated with the source code corresponding to at least two different revision history data sets in this first list.

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: Embodiments may provide a makefile interposer, which enables a makefile to be used for building software for different platforms without modifying the makefile. In some embodiments, the interposer intercepts the commands run by makefile and automatically interposes the correct library files, dependencies, paths, and other information used by make to build the program for a particular platform. Additionally, calls that the invoked tools themselves make are intercepted and the interposer may redirect them to the platform-specific tools or file system locations including redirecting file descriptors. In some instances, when a tool is called that is not in the platform, the interposer may also fall back on the other system tools.

Abstract: A method for analyzing changes in a software code may have the steps of: inputting a plurality of different versions of a plurality of software artifacts to a change analysis device, deriving design constructs of the software code of the software artifacts by using an abstract syntax tree analysis, with the software code differences between the different versions of each of the software artifacts, classifying the derived design constructs of each of the software artifacts according to the compared software code differences, and outputting a visualization of the design constructs of each of the software artifacts, which visualization is structured according to the classification of the design constructs.

Abstract: A method, system, and computer-readable medium for managing a work packet's life cycle, wherein the work packet is assembled in a software factory that creates custom software in a standardized manner, are presented. In a preferred embodiment, the computer-implemented method comprises the steps of: defining a work packet to perform a sub-function of a custom software, wherein the work packet is a pre-stored, reusable, self-contained, discrete unit of software code; assembling the work packet; archiving the work packet in an asset repository; retrieving the work packet from the asset repository; and sending the work packet to an assembly line for consolidation with other work packets to create a custom software.

Abstract: A version control system includes a mechanism for a learning roadmap based on information available from a source repository. More particularly, the mechanism generates an easily understandable timeline of a project and a directory of developers based on information available in the version control system that contains the source content of a project. The timeline for the project may be tied to the directory of developers. Under each date in the timeline, a list of developers and their roles and commits may be listed.

Abstract: This document describes, among other things, systems and methods for managing distributed parallel builds. A computer-implemented method to manage parallel builds, comprises identifying one or more software components in a software project, wherein each software component includes an executable binary file; determining a build configuration for each software component, wherein the build configuration includes a mapping from each software component to one or more build servers; and building each software component using the mapped one or more build servers in the corresponding build configuration, wherein the building includes compiling one or more source files associated with each software component to one or more object files, by distributing the one or more source files to one or more compilation machines.

Abstract: The present invention provides a technique of executing a suitable file from plural files of the same type. In a game apparatus, a ROM medium with game data recorded therein is loaded into a drive device. A patch file acquisition unit acquires a patch file for the game data, and stores the patch file in a HDD. The ROM medium and the patch file respectively include boot files for initiating a main program. An execution processor loads into the memory, the boot file having newer version information, and executes a boot sequence. The execution processor does not execute the boot sequence, when the ROM medium is not loaded into the drive device, and executes the boot sequence, as a condition that the ROM medium is loaded into the drive device.

Abstract: A method of software evolution, software evolution system and program product therefor. A context specification handler stores context specifications describing requirements on context-adapted software. A Software Part Semantics Specification (SPSS) handler stores software part semantics specifications. A Software Implementation (SI) handler stores SIs. Behavior History handler stores a history of active software behavior analysis results of monitoring previous versions. A software rendering handler combines software behavior history with context specification, software part semantics specifications and SIs and distributes (and optionally deploys) context-adapted software. A software inspector continuously monitors context behavior of deployed versions and selectively identifies active context-adapted software failing to satisfy context specification for reassembly of a new version(s).

Abstract: A method for software processing includes obtaining change information, which records changes that have been performed in respective locations in software code. The change information is processed so as to assign to at least some of the locations respective priorities, which are indicative of respective likelihoods that the locations contain program faults. The at least some of the locations are presented to a user in accordance with the assigned priorities.

Abstract: Software change management (SCM) systems can be extended to uniformly handle artifacts which lack constraints typically imposed on managed items. In the solution, a data type associated with a SCM system can enable management of unmanaged artifacts. Unmanaged artifacts can include, but is not limited to, artifacts which lack can traditional change management constraints, managed artifacts not directly associated with the SCM, artifacts with different constraints than the SCM imposed constraints, and the like. In one embodiment, an unmanaged artifact can have different lifecycles, policies, and the like which can make it unsuitable for traditional management approaches by the SCM. The SCM can utilize the data type to manage unmanaged artifacts without requiring significant change in functionality of the SCM by permitting change management processes to be applied to the unmanaged artifacts.

Abstract: Technologies are described herein for generating a management pack at program build time. Data is received that defines one or more events generated by the application program. Data is also received that defines one or more management classes for the application program. When a request to build the program is received, the data defining the events generated by the program and the data defining the management classes is utilized to generate a management pack for the program in an automated fashion. Once the management pack has been generated, it may be provided to an operations manager application program for use in monitoring the operation of the application program.

Abstract: A software artifact is scored for a user. Metadata associated with an artifact about project activity of how active an artifact project is to which the artifact belongs, a security risk indicated in the metadata of the artifact, or a license indicated in the metadata of the artifact, is collected from a software repository. A weighting of the artifact alone is determined from the metadata associated with the artifact that indicates desirability of the project activity, the security risk, or the license. The metadata associated with the artifact is compared to appropriateness with a metadata of a user project to which the user belongs as indicated by a profile of the user, so as to provide a score considering the determined weighting of the artifact and a appropriateness of the artifact for the user with respect to an intended use of the artifact by the user.

Abstract: A source control management system comprises accessing a TPF platform via a web interface. The system checks out a selected component of a package and transmits a copy of the component to a local computer for modification by a user. The user is able to edit and modify the component without having to download the entire package, which is much faster. Once the user completes the editing, the source control management system receives an edited copy of the component from the local computer. Furthermore, the system includes checking in the edited copy and comparing to the unedited component while providing component level warnings of differences. A second copy of the component may be transmitted for independent modification. This allows for multiple users to work on the same component at the same time. The multiple versions of the component are combined and the appropriate modifications are made to the primary component.

Abstract: Methods of detecting memory errors using write integrity testing are described. In an embodiment, additional analysis is performed when a program is compiled. This analysis identifies a set of objects which can be written by each instruction in the program. Additional code is then inserted into the program so that, at runtime, the program checks before performing a write instruction that the particular object being written is one of the set of objects that it is allowed to write. The inserted code causes an exception to be raised if this check fails and allows the write to proceed if the check is successful. In a further embodiment, code may also be inserted to perform checks before indirect control-flow transfer instructions, to ensure that those instructions cannot transfer control to locations different from those intended.

Abstract: A computer implemented method and apparatus for providing dependency traceability in software configuration management. Per configuration of a subject software program formed of one or more artifacts, a version history of each artifact is maintained. For each artifact, coupled to the respective version history of the artifact is an indication of status of traceability relationship for each indicated version. One implementation employs a traceability object to maintain and provide such status indications. The status indications are view independent and enable dependency traceability relationship of each artifact to be determinable in each configuration employing the artifact.

Abstract: A method and system for presenting an enterprise change and configuration report are provided. In accordance with one embodiment of the present application, a method for presenting an enterprise change and configuration report includes identifying at least one datasource that stored change management information, collecting change management information from the datasource and integrating the change management information into a change management report that is accessible via a web browser. A plurality of datasources that include change management data may be identified and change management data from each datasource of the plurality of datasources may be collected and integrated to provide the change management report.

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: Various embodiments of systems and methods to compare different versions of a development object based on a version comparison profile are described herein. Identities of the different versions of the development object are received. Further, a version comparison profile and a corresponding profile definition associated with the development object are received. Furthermore, the different versions of the development object are compared to determine one or more differences based upon the received version comparison profile and the corresponding profile definition. The determined one or more differences between the different versions of the development object are returned.

Abstract: An computing device obtains a delta between a first version of a target program and a second version of the target program that has been tested by one or more test routines. The computing device identifies a first portion of the second version of the target program that has not been tested in the first version of the target program and a second portion of the second version of the target program that has been tested in the first version of the target program based on the delta. to the computing device executes the one or more test routines on at least the first portion of the second version of the target program without executing the one or more test routines on the second portion of the second version of the target program.

Abstract: Server side internet applications are created by placing interactive server side components (ISSC's) on internet pages. ISSC's encapsulate dynamic page functions including processing of user responses on the server and thus can be reused, which drastically reduces programming effort. The ISSC technique remembers information (in form of an ISSC object) about each ISSC during dynamic page generation on the server. Then, it generates HTML code in a way such that the ISSC event is sent to the server using a conventional HTTP GET or POST request. On the server, the event is then passed to the corresponding ISSC object. All components work without disturbing each other, even when nested or combined. A browser based editor can also be used to place ISSC's on pages and to modify their properties. During dynamic page generation, scripts and handles are embedded into the page that permit editing of the page itself.

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 method, system and computer-usable medium for automatically tracking changes in an application such as, for example, a software solution. A particular definition can be created, which is indicative of an application artifact to be tracked during the development of the application, which includes the application artifact. The particular definition can be qualified by specifying a user authorized to modify the application artifact. The user can be identified by the particular role that the user plays during the development of the application. Thereafter, modifications to the application can be automatically tracked based on the particular role that the user plays during the development of the application with respect to the application artifact, thereby permitting modifications to the application to be tracked and recorded in a comprehensive manner.

Abstract: A system and method for facilitating installing software includes steps and means for identifying whether the phase of a software installing process changes and, responsive to the identifying a change in the phase of the software installing process, executing an additional task of the current phase of the software installing process.

Abstract: A computer code conflict notification and resolution technique that provides a collaborative programming environment for conflicts management is presented. The technique detects potential conflicts and provides facilities that allow programmers to work collaboratively to resolve the conflicts as they occur. This includes the ability to conduct a code session in which conflicting code elements are compared and changed as needed to resolve conflicts. In addition, in-place audio/video, text chat and application sharing is provided. This allows communication sessions to be conducted within the programming environment.

Abstract: A method provides network driver injection into a target image to transform the target image to be compatible with one or more source machines, for facilitating operating system streaming over a network. The method may include: facilitating access to a source system registry file of a source machine; facilitating access to a target system registry file of the target image, without copying the target image; determining whether source network interface cards of the source machine are compatible with the target image; and if the source network interface cards are not compatible with the target image, performing network interface driver injection into the target image. The target image may include an operating system. A machine-readable storage medium and apparatus are provided. A method is described for building a program for providing network driver injection into a target image to transform the target image to be compatible with computing machines.

Abstract: A computer system includes a transceiver and a processor that is cooperatively operable with the transceiver. The processor gathers, over the transceiver, (i) issue tracking information stored in an issue tracking storage system, the issue tracking information having a history of issues filed against a plurality of artifacts, and (ii) source code management information stored in a source code management storage system, the source code management information having a history of code changes committed against another plurality of artifacts. The processor checks a combined history of the issue tracking information and the source code management information for a history of issues filed against an artifact and a history of commits and corresponding source code changes committed against the artifact. The processor provides an interpretation of the current state of the artifact based on the combined history of the issue tracking information and source code management information about the artifact.

Abstract: The present invention describes a method and a computer program product for finding an impact of a change on a computer generated code. The method includes the generation of a dependency graph for the computer generated code. The dependency graph includes a plurality of nodes that are connected logically by one or more edges. The method enables an expert to assign nodal weights to the nodes, based on their importance. The method also enables the expert to assign edge weights and distribution ratios, based on the criticality of the relationship between the nodes and their distance from the root node. Thereafter, the impact of the change is found by implementing a spreading activation technique on the dependency graph. The output gathered after the activation represents the impact of the change on the computer generated code.

Abstract: Described is a method for synchronizing interdependent artifacts that are each modified independent of a modification to the other artifact after a last synchronization. Each artifact has a plurality of elements and is of a different formant from the other artifact. The method includes generating a temporary artifact having all the elements of a last synchronized version of the first artifact and having all the elements of a latest version of the second artifact transformed as the first artifact. The temporary artifact is merged with a latest version of the first artifact to create a synchronized version of the first artifact. A synchronized version of the second artifact having all the elements of the latest version of the second artifact and having all the elements of the synchronized version of the first artifact transformed as the second artifact is generated.

Abstract: A system resource manager of a site management server registers a server domain as a group of servers having a uniform physical wire connection. A software RM of the site management server and a software sub RM of a domain management server install, in cooperation with each other, a software used by a server that belongs to a registered server domain in a storage connected via a SAN, and causes the server to use installed software.

Abstract: A data processing method comprises maintaining a source code repository, checking out a component from the source code repository, checking in a modified version of the component to the source code repository, identifying the changes between the modified version of the component and the original component, applying one or more pattern matching techniques to the identified changes, storing the output of the pattern matching techniques, and displaying the output.

Abstract: Encoding a new version of a data module includes constructing a delta data module having data for providing the new version of the data module. The delta data module may indicate an encoding for copying data at an offset from one of a number of pointers into different versions of the data module. Decoding a delta data module to provide a new version of a data module includes copying, to the new version of the data module, data relative to a target pointer when an encoding in the delta data module indicates a matching pattern relative to the target pointer, and copying, to the new version of the data module, data relative to at least one other pointer when an encoding in the delta data module indicates a matching pattern relative to the at least one other pointer.

Abstract: Techniques to perform gradual upgrades are described. An apparatus may include a database with a data set for a first version of an application program, and a computing device to couple to the database. The computing device may have a processor and memory, with the memory to store a first version of an application program, an installer program, and a gradual update engine. The processor may execute the installer program to install a second version of the application program, and said gradual update engine to convert the data set to a data schema used by the second version one data segment at a time. Other embodiments are described and claimed.

Abstract: Encoding a new version of a data module includes constructing a delta data module having data for providing the new version of the data module. The delta data module may indicate an encoding for copying data at an offset from one of a number of pointers into different versions of the data module. Decoding a delta data module to provide a new version of a data module includes copying, to the new version of the data module, data relative to a target pointer when an encoding in the delta data module indicates a matching pattern relative to the target pointer, and copying, to the new version of the data module, data relative to at least one other pointer when an encoding in the delta data module indicates a matching pattern relative to the at least one other pointer.

Abstract: A method for providing codebase modification assistance includes receiving training data including learning application code prior to modification and the same learning application code subsequent to modification, the modification being of a known type. Portions of the learning application code that have been changed by the modification are detected. One or more substrings are identified from names associated with the detected portions of the learning application code that have been changed. A target application code that is to be modified according to the known type of modification of the training data is received. The identified one or more substrings are searched for from names associated with portions of the received target application code. The portions of the target application code for which the one or more substrings have been found within associated names are displayed.

Abstract: Compatibility determination apparatus and method can properly determine compatibility between elements in an electronic music apparatus. When a reproducing program holds version information indicating, for example, that the own version of the program is 4.0 and music contents of versions 1.0 and 2.0 are reproducible by the program, and a music content holds version information indicating, for example, that the own version of the music content is 3.0 and programs of versions 4.0 and 5.0 can be reproduced on the music content side, the program of version 4.0 can be reproduced on the music content side. Although the information held in the program side does not indicate that a music content of version 3.0 is reproducible by the program, the music content of version 3.0 can be reproduced by the program of version 4.0. Thus, the apparatus and method can properly determine compatibility between the elements.

Abstract: An entertainment device comprises communication means for communicating with a remote device over a network; program code and resources for running a full version of the program, the program code being operable to interact with remote devices also running a full version of the program; and program resource classification means, and in which when communication with a remote device indicates that the remote device is running a demonstration version of the program code; the program code on the entertainment device restricts the use of program resources to those identified by the program resource classification means as being available to or compatible with the demonstration version of the program, thereby restricting the full version of the program to operate substantially as a demo version of the program for the purposes of interaction with a demo version of the program being run on the remote device.

Abstract: The subject invention relates to systems and methods that facilitate display, selection, and management of context associated with execution of add-on instructions. The systems and methods track add-on instruction calls provide a user with call and data context, wherein the user can select a particular add-on instruction context from a plurality of contexts in order to observe values and/or edit parameters associated with the add-on instruction. The add-on instruction context can include information such as instances of data for particular lines of execution, the add-on instruction called, a caller of the instruction, a location of the instruction call, references to complex data types and objects, etc. The systems and methods further provide a technique for automatic routine selection based on the add-on instruction state information such that the add-on instruction executed corresponds to a current state.

Abstract: A method, system and computer-readable medium for creating software in a standardized manner are presented. The method includes the steps of: receiving, at a software factory, a description of software needs from a customer; creating, in the software factory, a project proposal that meets performance criteria found in the description of software needs; inducting the project proposal into the software factory, where inducting the project proposal initially evaluates the project proposal's compatibility with a capacity of the software factory; parsing the project proposal into major functional areas; retrieving work packets that are appropriate for the project proposal, where the work packets are pre-stored, reusable, self-contained, discrete units of software code; assembling the work packets into a deliverable software; testing the deliverable software; and delivering the deliverable software to the customer.

Abstract: The present invention discloses a method, apparatus and software for determining a relative measure of the risk of faults in a built product relative to a reference build of the product. The measure can be based on a balance between the additional risk added as a result of changes made in a given build and the risk reduction resulting from testing applied to the build. The product associated with the builds can be a software product, a firmware product, an electronic device, and/or any manufactured product.

Abstract: A mechanism is disclosed for operating local version-independent service program code for infrastructure services, wherein the mechanism is automatically and optionally linked to a central, remote service infrastructure, and wherein both an online and an offline processing mode is included and automatically supported, and wherein the mechanism is embedded in a generic runtime environment. In at least one embodiment, it contains service program code implemented in the runtime environment for calling by way of the application program code with standardized interfaces, wherein the service program code is intended for the provision of functionalities for predetermined services that an application program code can use.

Abstract: A system and method for selectively operating on changed elements, for example merging, in a software development environment are provided. A software project comprising one or more version-controlled software development objects, or elements, is associated with one or more defects recording changed elements in the software development environment. The system and method provide for automated merging of changed elements associated with defects tagged for forward merging into the software project, and association or tracking actions for changed elements associated with defects that are tagged as not to be merged. The process of automated merging is carried out using a master work list listing work items representing changed elements ordered chronologically.

Abstract: An International Testing Platform (ITP) provides a comprehensive, cohesive environment for managing testing and review validation activities for product versions scheduled to be released to market. An ITP allows each user to be part of a community of users whose work product is shared to generate a robust product test and review experience. An ITP also automates various testing and product review activities to increase verification throughput and reduce validation time and cost.

Abstract: A component name manager operates within an integrated development environment to assist developers in creating dynamic websites and Internet applications. The component name manager identifies an input field displayed on a graphical user interface of an object-oriented software development environment. The input field uses a fully-qualified name of a software component for accessing to access instructions and data associated with the software component and located at an application server. In response to receiving an input associated with the input field, the component name manager displays a list of qualified names of software components available for use in the object-oriented software development environment. Each of the qualified names identifies a path for accessing a corresponding software component. The component name manager can resolve fully qualified names by accessing one or more of an application file, an administrator interface, project level mappings, and global level preference mappings.

Abstract: Embodiments of the invention are directed to a configuration management (CM) system, method, and product adapted to carry out workflow management tasks, which integrates status of software projects and issues, such that software projects may be more easily and reliably tracked and management of software projects may be streamlined. In some embodiments of the invention, a CM system is adapted to maintain records of software projects and/or issues managed by the CM system, the records comprising an indicator of a workflow progress stage for the project/issue. The CM system may be further adapted to update concurrently and automatically, according to an input from a user, both (1) a workflow progress stage value for the project/issue and (2) a record for software code associated with a project/issue, the record for the software code indicating a version and the project/issue in which the version is included.

Abstract: A system facilitates verification of computer code. The system receives multiple versions of the computer code. A code verification engine checks the received code against one or more metrics, such as coding standard violations. A code differencing compares the received versions of computer code, and identifies the differences between them. An interactive presentation unit presents one or more analysis reports regarding coding violations located in the received versions. An analysis report includes a plurality of entries hierarchically organized in conformance with the entities of the received code. The analysis report indicates the number of coding violations identified for the entities of the received code in a side-by-side, comparative arrangement. A user can thus compare the number of coding violations present in the received versions.