Entries |
Document | Title | Date |
20080209399 | METHODS AND SYSTEMS FOR TRACKING AND AUDITING INTELLECTUAL PROPERTY IN PACKAGES OF OPEN SOURCE SOFTWARE - 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. | 08-28-2008 |
20080209400 | Approach for versioning of services and service contracts - 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. | 08-28-2008 |
20080222606 | GUIDED DEVELOPMENT AND TESTING FOR COMPUTER CODE - 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. | 09-11-2008 |
20080229282 | Patch-aware editor - 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. | 09-18-2008 |
20080244522 | APPARATUS AND METHOD FOR IDENTIFYING CONTEXTUAL CHANGES IN SOURCE CODE - 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. | 10-02-2008 |
20090019426 | SYNCHRONIZATION OF WORK SPACES - 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. Then the method comprises for the update operation being performed on the second workspace, retrieving into the second workspace in a load step from the version control system the change information and the refactoring information, performing a second refactoring operation using the refactoring information, and performing in an execution step an update of the object in the second workspace using the change information. | 01-15-2009 |
20090100410 | System and method for tracking software changes - 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. | 04-16-2009 |
20090138851 | AUTOMATED DEFECT CLASSIFICATION - 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. | 05-28-2009 |
20090144703 | Method and system for versioning a software system - 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. | 06-04-2009 |
20090172641 | RECYCLED VERSION NUMBER VALUES IN FLASH MEMORY - Various embodiments include methods, apparatus, and systems for assigning a plurality of version number values to instances of a logical entity of a memory device. Each version number value of the plurality version number values may be separately assigned to one of the instances of the logical entity. The version number values may be recycled after the plurality of version number values are assigned. Other embodiments including additional methods, apparatus, and systems are disclosed. | 07-02-2009 |
20090210859 | Infromation processing apparatus, information processing method, and function expansion program - Disclosed is an information processing apparatus provided with a software environment in which a function of the information processing apparatus is added and deleted by a plug-in and having a storage unit which stores, in a prescribed storage region, information that is composed of one or more attribute data and the function uses. The apparatus includes an information generation unit that has registration information in which a software component for constructing/deleting the attribute data of the information that the function uses is installed and registered in the information processing apparatus in accordance with the plug-in, specifies the software component used when the information is generated based on the registration information, and executes the specified software component to generate the information that the function uses; and an information management unit that instructs the information generation unit to generate the information designated in accordance with a request for generating the information. | 08-20-2009 |
20090293043 | DEVELOPMENT ENVIRONMENT INTEGRATION WITH VERSION HISTORY TOOLS - Instructions within an instruction set (such as source code for a software application) may be documented within many separate tools, such as a development environment, a version control system, and a bug report database. However, it may be inefficient to search for such information in many locations and through many interfaces while investigating the version history of an instruction. Instead, the development environment may be configured to retrieve relevant information (such as bug reports, versioning, and version release notes) and to display the version history information for a selected instruction together within the development environment. | 11-26-2009 |
20100037208 | HANDLE BASED METHOD FOR SIDE-BY-SIDE ASSEMBLIES IN A UNIX ENVIRONMENT - In some embodiments, an apparatus can comprise a memory unit including, two or more assemblies, wherein the two or more assemblies include a first assembly and a second assembly, wherein the second assembly is a later version of the first assembly, and wherein the first and second assemblies include, a stub module configured to detect an assembly initialization request indicating one of the first or second assemblies. The stub module can also be configured to retrieve a reference to a symbol table associated with the one of the first and second assemblies indicated in the assembly initialization request, to store data in the symbol table, and to provide the reference to a caller. The memory unit can also comprise an implementation module configured to perform operations associated with symbols in the symbol table and a processor configured to receive and execute one or more of the stub and implementation modules. | 02-11-2010 |
20100050156 | USING BUILD HISTORY INFORMATION TO OPTIMIZE A SOFTWARE BUILD PROCESS - Methods and systems for optimizing a build order of component source modules comprises creating a dependency graph based on dependency information. Historical build information associated with previous build failures is then used to calculate relative failure factors for paths of the dependency graph; and the relative failure factors are used to determine an order of traversal of the dependency graph during a build process in which component binary modules are built from the component source modules. | 02-25-2010 |
20100058294 | GUARDING CODE CHECK-IN WITH TEST CASE EXECUTION RESULTS - A mechanism for providing a source code control system that employs test case execution results to mandate that software code have a specific level of quality for check-in to a central repository. A request to check-in a modified copy of a source code file to a repository is received, wherein the modified copy comprises changes to the source code file located in the repository. The modified copy of the source code file is placed in a quality check pending state in the repository. Responsive to an occurrence of a specific event or expiration of a set time period, applicable regression test cases are executed against the changes in the modified copy. A determination is made as to whether the regression test cases are successful. If the regression test cases are successful, the changes in the modified copy are committed to the source code file located in the repository. | 03-04-2010 |
20100064279 | Instrumentation for Real-Time Performance Profiling - A method of source code instrumentation for computer program performance profiling includes generating ( | 03-11-2010 |
20100125831 | INTERFACE VERSIONING - A system and method of interface visioning to improve extendibility and flexibility in modular software design. A first super class implements a first interface. A second super class implements both a first interface and a second interface. Each super class has a unique version designation. An access class is instantiated when a feature using an interface is requested. The access class identifies from the feature the version designation and provides access to the appropriate interface through either the first super class or the second super class. | 05-20-2010 |
20100131926 | SYSTEM AND METHOD FOR MANAGING A SOFTWARE ASSET FOR INCLUSION IN A SOFTWARE LIBRARY - A system for managing a software asset including asset files for inclusion in a library includes: (a) a receiving manager configured for receiving the asset, verifying source of the asset and reading an installer package into the asset to establish a received asset; (b) a build manager coupled with the receiving manager and configured for creating an application wrapper file for the received asset; the build manager creating folders in a folder structure and distributing the asset files among the folders to establish a distributed folder file; the build manager using the distributed folder file to create the application wrapper file; and (c) a peer review manager coupled with the build manager and effecting a peer review process with the application wrapper file to establish a reviewed application wrapper file; the peer review manager unit cooperating with the build manager to present the reviewed application wrapper file to the library. | 05-27-2010 |
20100153919 | SYSTEMS AND METHODS FOR TRACKING SOFTWARE STANDS IN A SOFTWARE PRODUCTION LANDSCAPE - According to some embodiments, a first container, representing a first uniquely addressable physical location in a software production landscape, may be associated with a first series of stand snippets related to a software product. Similarly, a second container, representing a second uniquely addressable physical location in the software production landscape, may be associated with a second series of stand snippets related to the software product. Information about a sequence of stand snippets may then be automatically provided to a user, wherein the sequence may include stand snippets from both the first and second containers. | 06-17-2010 |
20100153920 | METHOD FOR BUILDING AND PACKAGING SOFWARE - A method and apparatus for building a source code based on a project object model (POM) from a source control and for tracking a build environment of the source code is described. Plugins to complete the build as configured in the POM are downloaded from an external plugin repository. A local plugin repository is scanned to determine which plugins have already been downloaded. The local plugin repository is rescanned to determine whether any additional plugins and associated plugins POM files were downloaded during the build as build dependencies. Information of one or more referenced files is inserted into a database wherein the referenced files are identified as build dependencies. Information about the newly-built plugins and associated plugins POM files in the output directory are extracted and added to the database for use by subsequent builds. | 06-17-2010 |
20100211931 | STM WITH GLOBAL VERSION OVERFLOW HANDLING - A software transactional memory system is provided with overflow handling. The system includes a global version counter with an epoch number and a version number. The system accesses the global version counter prior to and subsequent to memory accesses of transactions to validate read accesses of the transaction. The system includes mechanisms to detect global version number overflow and may allow some or all transactions to execute to completion subsequent to the global version number overflowing. The system also provides publication, privatization, and granular safety properties. | 08-19-2010 |
20100251212 | Version Type Traversal - A version traversal system for objects, such as types, may include a reference to another version of an object with the type definition. The reference may be used to identify an older or newer version of the object which may be in a different assembly and may have a different simple name. The version traversal system may be used to compile applications written for the first version but compiled with assemblies from the second version, as well as serializing and deserializing objects from one version to another. The version traversal system may enable two way communications between applications that use two versions of a set of assemblies. The reference may include a fully qualified name or other identifiers. | 09-30-2010 |
20100269099 | Software Reuse Support Method and Apparatus - A likelihood indicating the distribution of the frequency of use of each specification of the existing device is calculated for each version of a software component used in the control software of the existing device, and a prior probability indicating the distribution of the frequency of use of each version is calculated for each software component used in the control software of the existing device. A posterior probability indicating the reusability of each version of the existing software component is calculated for each specification of a device to be developed, on the basis of the likelihood and the prior probability. | 10-21-2010 |
20100318967 | SUPPLEMENTARY DEPLOYMENT ACTIONS - A system and method for enabling supplementary deployment actions to be performed in conjunction with a deployment of an application version. A deployment manager may download one or more supplementary deployment action (SDA) components to a user application cache. In conjunction with performing deployment actions, SDA components may be invoked from the user application cache or from a global application cache. The SDA components may perform actions specific to the application or version of the application, including actions not preconfigured in the deployment manager. An SDA component may be invoked prior to or after the deployment manager performs deployment actions. If an SDA component fails, SDA components that succeeded may be automatically invoked to roll back their actions. SDA components may be used to perform a first install, an update, a roll back, or an uninstall. SDA components may have the privileges of the application and the user corresponding to the user application cache. | 12-16-2010 |
20100318968 | CATALOG-BASED SOFTWARE COMPONENT MANAGEMENT - Multiple software component identifiers are maintained in a catalog of an operating system running on a device. Each of these software component identifiers corresponds to one of multiple software components installed on the device. The catalog is accessed in response to a request regarding one of the multiple software components, and the request is responded to based at least in part on information included in the catalog. Additionally, two or more versions of a software component that are installed on the computing device can be identified. Which one of the two or more versions of the software component is an active version of the software component to be run is determined. In response to requests for information regarding the software component, information regarding the active version of the software component is returned. | 12-16-2010 |
20110072416 | Selectively Applying Changes to a Version of a Component - Controlling how changes made to a version of a reusable component (e.g., for displaying in a graphical user interface) are applied, or not applied, to another version or versions of that component. A variation is defined, the variation comprising a set of overridden property values for the component. The variation is derived from a version of the component, and inherits property values from the version and also from its ancestors, if applicable. To reuse the component, the reuse may be derived from the variation, in which case the reuse inherits the overridden property values through the variation, provided the variation is turned on, and through the version from which the variation was derived if the variation is turned off. A particular variation may be turned on and off within an inheritance chain. | 03-24-2011 |
20110078659 | Java-Based Application Server that Supports Multiple Component Models - A Java-based application server supports runtime operations of components that belong to multiple component models. The components may cross-reference each other. A component of a source component model can be integrated into a target component model to form an integrated component. State transitions of the integrated component can be managed according to the target component model with reference to the libraries of the source component model. The integrated component can be installed in the application server for execution by a Java virtual machine. | 03-31-2011 |
20110088013 | METHOD AND SYSTEM FOR SYNCHRONIZING SOFTWARE MODULES OF A COMPUTER SYSTEM DISTRIBUTED AS A CLUSTER OF SERVERS, APPLICATION TO DATA STORAGE - A method for synchronizing software modules of an IT system distributed across plural servers interconnected as a network, each software module being executed on a server of the IT system for management of a set of data elements describing a service, and at least a part of descriptive data elements is replicated on plural software modules. The method includes: execution, on a first software module, of an action acting on a descriptive data element, transmission of a synchronization message identifying the action to all the other software modules of the IT system including a replication of this descriptive data element, and on receipt of this message by any of the software modules concerned, execution of the action identified on this software module so as to act on the replication of the descriptive data element located on this software module. | 04-14-2011 |
20110161932 | TECHNOLOGIES FOR CODE FAILURE PRONENESS ESTIMATION - The present examples provide technologies for estimating code failure proneness probabilities for a code set and/or the files that make up the set. The code set being evaluated is typically comprised of binary and/or source files that embody the software for which the estimates are desired. The estimates are typically based on a set of selected code metrics, the code metrics typically selected based on corresponding failures of a previous version of the software. A historically variant metric feedback factor may also be calculated and code metric values classified relative to a baseline code set embodying the previous version of the software. | 06-30-2011 |
20110209119 | INTERACTIVE ITERATIVE PROGRAM PARALLELIZATION BASED ON DYNAMIC FEEDBACK - Interactive iterative program parallelization based on dynamic feedback program parallelization, in one aspect, may identify a ranked list of one or more candidate pieces of code each with one or more source refactorings that can be applied to parallelize the code, apply at least one of the one or more refactorings to create a revised code, and determine performance data associated with the revised code. The performance data may be used to make decisions on identifying next possible ranked list of refactorings. | 08-25-2011 |
20110246964 | Archiving a Build Product - An enhanced integrated development environment (IDE) is able to archive a build product and/or work with an archived build product in various ways. In one embodiment, a build product archive includes a manifest, a source code snapshot, a symbol table, and a build product. The manifest contains meta-data about the archive. The source code snapshot is a copy of the source code that was used in the build process. The symbol table is a copy of the symbol table that was generated by the build process. The build product is a copy of the build product that was generated by the build process. A developer can use the enhanced IDE to help share a build product with others and/or to understand system logs and reports that describe operation of the build product (e.g., crash logs and memory logs). | 10-06-2011 |
20110258599 | TEST AUTOMATION METHOD FOR SOFTWARE PROGRAMS - A method for testing a software program creates test data by simulating data exchange messages between a server and a client and stores test data in Comma Separated Value (CSV) files. Data repository files stored in the CSV format can be edited by common tools, like a spreadsheet program, and can be maintained easily. The test automation method provides a data capturer tool so that the data repository could be created based on any existing test environment. The test automation method converts data repository files and simulates messages in order to load data to a mobile infrastructure system and set up data fixtures. The test automation method could be integrated in a build process so that data repository and test cases are validated against any program changes periodically. | 10-20-2011 |
20110289479 | METHODS AND SYSTEMS FOR PROVIDING A USER INTERFACE IN A MULTI-TENANT DATABASE ENVIRONMENT - Methods, devices and systems for providing a user interface in an on-demand software service environment are described. Some implementations involve receiving an indication of a component definition to instantiate. The component definition may be a portion of a component definition data structure. Such implementations may also involve instantiating the provided component, instantiating all remaining attributes of the component definition data structure to produce a component instance data structure and transmitting an intermediate representation of the indicated component to a client device. The intermediate representation may comprise a version of the component instance data structure. The intermediate representation may allow the client device to create an instance of the component in memory. | 11-24-2011 |
20110296380 | METHODS AND SYSTEMS FOR PRESENTING DIFFERENT VERSIONS OF AN APPLICATION - Methods and systems for presenting different versions of an application are described. In one example, a selection of a version of application code is received. Such a selection may include a simultaneous selection of all versions. Information about the selected version is retrieved. A description of features contained within the selected version is presented and then a version summary for each listed feature is displayed, together with the description of features, to indicate the versions of the application code that contain the respective feature. | 12-01-2011 |
20110296381 | ADDING DIRECTIVES FOR VERSIONS OF JAVASCRIPT FILES DIRECTLY INTO SOURCE CODE IN A MULTI-TENANT DATABASE ENVIRONMENT - In a method, system, and computer-readable medium having instructions for adding directives for versions of JavaScript files directly into source code, a source file for preprocessing is received and the source file is written in a client-side scripting language, the source file is parsed, directive information is identified for a directive within the source file and the directive information comprises data on at least a portion of a client-side scripting language file and a mode, a version of the source file for the mode is created and the version of the source file comprises source code from the source file and the at least a portion of the client-side scripting language file, and metadata is associated with the directive and the version of the source file. | 12-01-2011 |
20110321012 | Non-Intrusive Measurement of Content Quality Using Dry Runs with Roll-back - Validation and determination of business application program content quality destined for loading on a target production computing environment is automated by receiving an application program into a controlled production computing environment, and, during a dry run test in the production computing environment, logging changes to content from an initial state as loaded by the application program; applying a business rule to the content during data loading to validate against business objects; capturing validation errors produced by the validation and structural change commands to the content into a log file; and automatically rolling back changes made to the content during the dry run test to the initial state thereby avoiding committing content changes to the production computing environment. | 12-29-2011 |
20120036497 | INTEGRITY CHECK WHILE COMMITTING CHANGES FROM AN INTEGRATED DEVELOPMENT ENVIRONMENT TO A SOURCE CODE CONTROL SYSTEM - Integrity check is performed on selected items that are to be committed to storage from an integrated development environment. Integrity check utilizes dependency relationship table to determine implicit changes in items occurring due to explicit changes made to the related items. | 02-09-2012 |
20120096436 | SYSTEMS, METHODS AND APPARATUS FOR DEVELOPING AND MAINTAINING EVOLVING SYSTEMS WITH SOFTWARE PRODUCT LINES - Systems, methods and apparatus are provided through which an evolutionary system is managed and viewed as a software product line. In some embodiments, the core architecture is a relatively unchanging part of the system, and each version of the system is viewed as a product from the product line. Each software product is generated from the core architecture with some agent-based additions. The result may be a multi-agent system software product line. | 04-19-2012 |
20120131553 | SOURCE CODE FILE MANAGEMENT SYSTEM AND METHOD - A source code file management system includes a first receiving module, a generating module, a retrieving module, a determining module, a transmitting module, a second receiving module, a storing module and a message module. The first receiving module receives a source code file from a developer client associated with a developer. The generating module generates an intermediate file based on the source code file. The retrieving module retrieves a developer profile associated with the developer. The determining module determines examiners according to the developer profile. The transmitting module transmits the intermediate file to examiner clients associated with the examiners. The second receiving module receives examining results from the examiner clients. The storing module stores the source code file in a source code storage when each examining result is accepted. | 05-24-2012 |
20120151444 | ON-DEMAND DATABASE SERVICE SYSTEM AND METHOD FOR DETERMINING WHETHER A DEVELOPED APPLICATION WILL OPERATE PROPERLY WITH AT LEAST ONE OTHER APPLICATION - In accordance with embodiments, there are provided mechanisms and methods for determining whether a developed application associated with an on-demand database service will operate properly with at least one other application. These mechanisms and methods for providing such determination can enable embodiments to ensure that new versions of developed applications will operate in the same application environment of a previous version. The ability of embodiments to make such determination may lead to an improved application migration development/runtime framework, etc. | 06-14-2012 |
20120167047 | SYSTEM AND METHOD FOR AUTOMATIC CREATION OF WEB CONTENT FOR MOBILE COMMUNICATORS - A method for creating applications optimized for use on multiple mobile devices, the method including using a computer to generate a single version of an application including at least one of content and functionality, providing the single version of the application via a computer network to a mobile device adaptation server and employing the mobile device adaptation server to automatically modify the single version of the application so as to create multiple versions corresponding to the single version, each of the multiple versions being optimized for at least one different mobile device platform. | 06-28-2012 |
20120167048 | SYSTEMS AND METHODS FOR BUILDING SOFTWARE PACKAGES IN SECURE DEVELOPMENT ENVIRONMENTS - The mock tool can be configured to create a mock execution environment for building software packages. The mock execution environment is isolated from resources of the computing system supporting the mock execution environment and other mock execution environments. Further, the mock execution environment can be created to simulate disabling on any features of the operating system supporting the mock execution environment that could cause problems in the building the software packages. | 06-28-2012 |
20120174066 | Documentation Roadmaps and Community Networking for Developers on Large Projects - 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. | 07-05-2012 |
20120204152 | Determining Deltas in a Spatial Locality of a Function Call Graph in a Source Controlled System - In and for software projects, arrangements for permitting a user to understand how the spatial locality of a function call may have changed with respect to any changes in a function definition. This permits an analysis of different workflows which use the same function, wherein the definition of the function may have changed. To the extent that there might be corresponding changes in the workflows which use such a function, the user will readily develop an idea of why some workflows changed and some did not. The invention method and apparatus determine and display deltas (changes) between different versions of a file where the function call occurs. | 08-09-2012 |
20120222007 | AUTOMATED DEFECT CLASSIFICATION - 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. | 08-30-2012 |
20120246617 | BUILD PROCESS MANAGEMENT SYSTEM - A build process management system can acquire data pertaining to a software build process that is currently being executed by an automated software build system. The software build process can include executable process steps, metadata, and/or environmental parameter values. An executable process step can utilize a build artifact, representing an electronic document that supports the software build process. The acquired data can then be synthesized into an immutable baseline build process and associated baseline artifact library. The baseline artifact library can store copies of the build artifacts. The immutable baseline build process can include baseline objects that represent data values and dependencies indicated in the software build process. In response to a user-specified command, an operation can be performed upon the baseline build process and associated baseline artifact library. | 09-27-2012 |
20120246618 | METHOD AND A SYSTEM FOR GENERATING A SOFTWARE PRODUCT - A computer-implemented method executed by a server processor for generating a software product comprises generating modules, each module being described by module metadata, and for each generated module, adding dependencies on other modules to the module metadata, creating a nest, the nest comprising data describing a development environment of a client processor for the module, and adding the nest to the module metadata, and further comprising storing the module metadata with a database connected to the server processor, providing a created nest to the client processor for being loaded into the development environment of the client processor, and building the module and publishing the built module to a publication repository connected to the server processor. Furthermore, there is provided a system for generating a software product and being adapted for performing the computer-implemented method. | 09-27-2012 |
20120284694 | SYSTEM AND METHOD FOR MANAGING SOURCE CODE AND ACQUIRING METRICS IN SOFTWARE DEVELOPMENT - A method and system is described for managing the development of software source code, and in addition, collecting useful metrics about the development process. A first source code is provided in a desired state. The desired state may be the requirement that the source code can be built or the desired state may be the requirement that the source code can be built and pass one or more tests. A second source code is then received. The second source may be a modified copy of the source code. It is then determined whether the second source code is in the desired state, and the first source code is updated using the second source code in response to the second source code being in the desired state. Metrics that may be collected include: the name of a task, time to complete the task, line of code involved, etc. | 11-08-2012 |
20120297363 | INFERRED AND SHARED SOURCE CONTROL INTEGRATION ACROSS MULITIPLE PROGRAM DEVELOPMENT TOOLS - An integrated system is provided for synchronizing source code development in an external program development application with source code development in an internal program development environment as a part of a separate Enterprise Management Application (EMA). The integrated system allows for source control operations to be executed in an external program development application and the source control operations to be synchronized with the source code control system contained in the EMA. The source code control system may enable multiple users in a collaborative development environment to modify source code elements on each user's local program development environment, and user modifications may be synchronized with the source control and updated in the source control system to reflect editing status of repository elements in the source control and the latest updated version of a source code element in the source control system repository. | 11-22-2012 |
20130014083 | AUTOMATED MERGING IN A SOFTWARE DEVELOPMENT ENVIRONMENT - 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. | 01-10-2013 |
20130074038 | METHOD AND SYSTEM FOR EVALUATING A SOFTWARE ARTIFACT BASED ON ISSUE TRACKING AND SOURCE CONTROL INFORMATION - 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. | 03-21-2013 |
20130091490 | METHOD TO AUTOMATICALLY DISCOVER WHETHER NEW CODE IS COVERED BY TESTS - 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. | 04-11-2013 |
20130097585 | PROFILE BASED VERSION COMPARISON - 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. | 04-18-2013 |
20130111443 | Methods and Systems for Source Control Management | 05-02-2013 |
20130152046 | Method for Analyzing Changes in a Software Code and Software Analysis System - 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. | 06-13-2013 |
20130167120 | RETRIEVING REVISIONS IN SOURCE CODE FROM A PLURALITY OF REVISION HISTORY DATA SETS - 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. | 06-27-2013 |
20130174124 | VERSION NUMBERING IN SINGLE DEVELOPMENT AND TEST ENVIRONMENT - 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. | 07-04-2013 |
20130198720 | Just in Time Component Mapping - One embodiment involves a system comprising a network, a server, and a requesting device. The server and requesting device are connected with the network. The server comprises a processor configured to receive a request from the requesting device and determine information about the requesting device based at least in part on the request. The processor is further configured to determine an abstract representation of an application and at least one mapping from a plurality of mappings based at least in part on the information about the device. The abstract representation comprises a plurality of components. Each mapping comprises an attribute for at least one of the plurality of components. The processor is further configured to generate a version of the application on-the-fly based at least in part on the abstract representation and the at least one mapping and send the version of the application to the requesting device. | 08-01-2013 |
20130227525 | Delivery of Changesets by Environment - A method for allowing selective delivery of changesets by environment includes selecting at least one value in software code of a software program; specifying at least one environment for the selected at least one value; compiling the software code in each specified at least one environment; delivering the software code to a central repository; determining how the specified at least one environment is defined; and choosing at least one environment to build against, thereby ensuring that only software code for the chosen environment is pulled from the central repository. | 08-29-2013 |
20130227526 | SOFTWARE DEVELOPMENT AND DISTRIBUTION WORKFLOW EMPLOYING META-OBJECT TIME STAMPING - A method and system facilitating the development and distribution of software is provided. The system includes tracking revisions to elements of a database on the computing device by establishing time stamps for each stored element changed at a specified time, enabling a user to select an applicable time period comprising a beginning time point and an end time point, and assembling elements for execution based on time stamps limited to the selected applicable time period. | 08-29-2013 |
20130275943 | DETERMINING INTERFACE DIFFERENCES BETWEEN DIFFERENT VERSIONS OF AN OPERATING SYSTEM - An aspect of the present invention determines interface differences between different versions of an operating system. In one embodiment, the corresponding images of a first (older) version and a second (newer) version is inspected to identify whether access mechanism of a publicly accessible resource associated with a first interface provided by the first version is changed in the second version. Example of change in access mechanism includes a difference in the signature of function type resources, non-existence or change in the name or location of a file type resource and change in the physical file pointed to by a symbolic link type resource in the second version (as compared to that in the first version). A list of publicly accessible resources that are identified as having changed in the second version is then formed. | 10-17-2013 |
20130283235 | BUILD SYSTEM REDIRECT - 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. | 10-24-2013 |
20130290931 | COMPUTER METHOD AND APPARATUS FOR ENGINEERED PRODUCT MANAGEMENT INCLUDING SIMULTANEOUS INDICATION OF WORKING COPY STATUS AND REPOSITORY STATUS - 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. | 10-31-2013 |
20130326480 | VERSION LABELING IN A VERSION CONTROL SYSTEM - Version labeling of an artifact in a version control system. An embodiment can include accepting at least one change set into a configuration for the artifact. Based on the change set, a new version of the artifact can be selected by the configuration. Via a processor, an identifier can be generated for the newly selected version of the artifact. The identifier can include at least a branch name for a branch in which the newly selected version of the artifact is contained and a sequence number for the newly selected version of the artifact. The newly selected version of the artifact can be labeled with the generated identifier. | 12-05-2013 |
20130332902 | VISUALIZED CODE REVIEW - Visualization of the result of user interface code is provided in the context of code review. Changes to user interface code can be visualized to enable code reviewers to easily understand the effect of such changes. Furthermore, the visualization, or view, provides a surface for users to provide precise feedback to a developer. | 12-12-2013 |
20130339928 | ADAPTIVE PORTABLE LIBRARIES - Platform-agnostic source code can be augmented with one or more portions of source code annotated for different platforms and/or versions. The source code including both the platform-agnostic and platform-specific and/or version-specific portions can be compiled once to create a single executable that can be distributed to and can run on multiple device platforms and/or multiple versions of one or more platforms. Platform-specific or version-specific executables (e.g., assemblies, binaries, etc.) can be embedded into a binary or executable as resources (e.g., data). When the compiled code is executed on a device, the runtime can extract the platform-specific portion corresponding to the device on which the executable is being run, can bind the extracted portion to the executable and can load and execute the executable. Hence the same binary can produce different results or functionalities depending on the capabilities of the platform on which the binary runs. | 12-19-2013 |
20140068561 | CONTROL SYSTEM HAVING AUTOMATIC COMPONENT VERSION MANAGEMENT - A component version management system for a machine is disclosed. The component version management system has a software driven component located on the machine, a data system located offboard the machine, and a data system controller in communication with the software driven component and the data system. The data system controller is configured to automatically collect at least one of a software and hardware version of the component, analyze the information for at least one of software and hardware mismatch, and generate a notification for display in the machine when software or hardware mismatch is detected. | 03-06-2014 |
20140089896 | END-TO-END CONTINUOUS INTEGRATION AND VERIFICATION OF SOFTWARE - Systems and methods of end-to-end continuous integration and verification of software are described. A system comprises, for example, a provisioning service module configure to automatically retrieve source code from a source code management system. The provisioning service module further generates one or more environments. A propagation management module is configured to package the retrieved source code into a deliverable and to automatically propagate the deliverable through a pipeline comprising the one or more environments. | 03-27-2014 |
20140089897 | INTEGRATED EXCHANGE OF DEVELOPMENT TOOL CONSOLE DATA - Embodiments of the present invention provide a method, system and computer program product for exchanging console data in a messaging system. In an embodiment of the invention, a method for exchanging console data in a messaging system includes receiving a message in a messaging client executing in memory by at least one processor of a computer. The method further includes selecting in the message in the messaging client a portion of console data for a version of source code. For instance, the console data can be a selection of source code or an error message for a selection of source code. Finally, in response to the selection of the portion of console data, corresponding meta-data for the message can be extracted and a version of source code for the console data can be determined from the meta-data. Finally, the version of the source code can be loaded in an IDE executing in the memory by the at least one processor of the computer. | 03-27-2014 |
20140123106 | COMPOUND VERSIONING AND IDENTIFICATION SCHEME FOR COMPOSITE APPLICATION DEVELOPMENT - The present invention provides a method, a system and a computer program product for defining a version identifier of a service component. The method includes determining various specification levels corresponding to the service component. Thereafter, the determined specification levels are integrated according to a predefined hierarchy to obtain the version identifier of the service component. The present invention also enables the identification of the service components. The service components are identified from one or more service components on the basis of one or more user requirements. | 05-01-2014 |
20140165037 | REUSABLE APPLICATION USER EXPERIENCE - Reusable user experience is provided by way of styleable applications. An application can be segmented into a content portion and a style portion, if not originally designed that way. Subsequently, alternate style code can be injected to provide a style to an application lacking style or replace a style with a different style. Styles can be extracted from other applications or acquired from an online marketplace, for instance. | 06-12-2014 |
20140173559 | IDENTIFYING DIFFERENCES BETWEEN SOURCE CODES OF DIFFERENT VERSIONS OF A SOFTWARE WHEN EACH SOURCE CODE IS ORGANIZED USING INCORPORATED FILES - An aspect of the present invention identifies differences between source codes (e.g. of different versions of a software), when each source code is organized using incorporated files. In one embodiment, in response to receiving identifiers of a first and second source codes (each source code being organized as a corresponding set of code files), listings of the instructions in the first and second source codes are constructed. Each listing is constructed, for example, by replacing each incorporate statement in the source code with instructions stored in a corresponding one of code files. The differences between the first and second source codes are then found by comparing the constructed listings of instructions. | 06-19-2014 |
20140173560 | DYNAMICALLY UPDATING CODE WITHOUT REQUIRING PROCESSES TO RESTART - A method, system and computer program for dynamically updating code managed by an authorized agent. The method includes executing multiple versions of agent code in system memory. One version of the agent code is executed as an active version and another version of the agent code is executed as an inactive version. Version numbers of the active and inactive versions of the agent code are stored in a reloadable module vector. Client instances previously bound to the inactive version of the agent code are bound to the active version of the agent code after comparing the version numbers of the active version of the agent code and the inactive version of the agent code. A portion of the system memory used by the inactive version of the agent code is deallocated when no client instances are bound to the inactive version of the agent code. | 06-19-2014 |
20140282399 | SMART ENDPOINT ARCHITECTURE - A network-based application development and distribution platform allows application developers to build, modify, and configure dynamic content applications (especially mobile applications) remotely, and without requiring manual software coding. Smart endpoints facilitate creation of distributable applications for multiple operating systems, form factors, access methods, and/or device types, while creating only a single product and associating the product with the desired endpoints corresponding to the operating systems, form factors, access methods, and/or device types. The platform also facilitates software updates, as updates can be made to the product once, rather than once for each version of the application. | 09-18-2014 |
20140282400 | SYSTEMS AND METHODS FOR MANAGING SOFTWARE DEVELOPMENT ENVIRONMENTS - Systems and methods for branched development environments enable construction of development and deployment environments for use at various stages of software development and delivery. Various embodiments are configured to deliver these constructed environments to reproduce faithfully the state of an application at a given revision of the application's source or configuration. The branched development system can be configured to use the constructed environments to offer a variety of novel results and benefits that simplify the development, test, deployment, and debugging tasks commonly associated with software throughout its lifecycle. | 09-18-2014 |
20140337819 | SEMANTIC BASELINING - Described herein are technologies pertaining to semantic baselining. Correctness conditions of a baseline program are inferred based upon a first static analysis undertaken over the baseline program. The correctness conditions are subsequently inserted into a revision to the baseline program. When a second static analysis is undertaken over the revised program with the correctness conditions inserted therein, warnings inherited from the baseline program are suppressed, while warnings caused by revisions are surfaced to a developer. | 11-13-2014 |
20140351792 | Version Construction System and Method - A version construction system and method are disclosed. The system includes: a master control server, configured to: generate a control command according to an obtained request, correspondingly send the control command to a version construction server, and generate receipt information according to construction information reported by the version construction server, wherein the control command comprises a version construction command; the version construction server connected to the master control server, configured to: send the version construction command or complete flow command from the master control server to version construction machines, and report construction information fed back by the version construction machines to the master control server; and the version construction machines connected to the version construction server, configured to: construct software and hardware versions according to the version construction command or the complete flow command received from the version construction server, and feed back construction information to the version construction server. The above version construction system and method are beneficial to improve efficiency and shorten the development cycle. | 11-27-2014 |
20140366002 | SEARCHING FOR AN ENTITY MOST SUITED TO PROVIDE KNOWLEDGE REGARDING AN OBJECT - In some example implementations, there is provided a method. The method may include receiving a message from a user interface, the message representing a request for an identity of an entity having information regarding a component of a system being developed; determining whether a cache includes the identity of the entity having the information regarding the component; accessing, from at least a repository, metadata including at least one of a version information for the component and an organization structure information, when the cache does not include the identity of the entity having the information regarding the component, and determining, based on the accessed metadata, the entity, when the cache does not include the identity of the entity having the information regarding the component. Related systems, methods, and articles of manufacture are also provided. | 12-11-2014 |
20150046904 | OBSERVING EVOLUTION OF SOFTWARE DEVELOPMENT ARTIFACTS - Methods, systems, and computer-readable storage media for providing notifications in distributed development. In some implementations, actions include receiving change information, the change information indicating one or more changes to source code, processing the change information to determine one or more entities associated with the change, comparing the one or more entities to one or more subscriptions, the one or more subscriptions being specific to a user, for each entity associated with a subscription, providing a notification in a set of notifications, and providing a sub-set of notifications for display to the user. | 02-12-2015 |
20150046905 | SUBPROCESS DEFINITION AND VISUALIZATION IN BPEL - A system and method for enabling reuse of a portion of a business process. An example method includes employing a business process language to facilitate accessing a definition of a subprocess characterizing the process logic, wherein the definition indicates one or more parameters to be used by the subprocess to implement a task specified by the process logic; and employing the definition to facilitate: using one or more variables of a parent process as one or more arguments that are passed to an instantiated version of the subprocess, and mapping the one or more arguments to the one or more parameters. In a more specific embodiment, the example method further includes characterizing a behavior of the subprocess via one or more dynamic scoping rules. The business process language includes a version of Business Process Execution Language (BPEL), and a BPEL extension activity facilitates defining the subprocess. | 02-12-2015 |
20150074643 | MANAGING REUSABLE ARTIFACTS USING PLACEHOLDERS - Arrangements described herein relate to managing reusable artifacts. Responsive to receiving a request to create a placeholder for a reusable artifact representing a reusable unit, the placeholder for an appropriate version of the reusable artifact is created within a container and a first parameter identifying the reusable artifact is assigned to an artifact property of the placeholder. The placeholder further includes a branch property configured to indicate a first null value or a second parameter identifying a branch of the reusable artifact corresponding to a particular variant of the reusable artifact, and a version property configured to indicate a second null value or a third parameter identifying a particular version of the reusable artifact. | 03-12-2015 |
20150074644 | SYSTEM AND METHOD FOR DETERMINING COMPONENT VERSION COMPATIBILITY ACROSS A DEVICE ECOSYSTEM - A system and method that include collecting device version profiles from a plurality of device sources; classifying the device version profiles into a device profile repository; receiving a component version query request; querying the device profile repository according to the version query request; and responding to the query request with results of the query. | 03-12-2015 |
20150089476 | Program Integration that Accommodates Restrictions on Merge-Locations - Methods, systems, and articles of manufacture for program integration are provided herein. A method includes identifying each varying portion of a customized version of a program as compared to a standard version of the program; identifying each common portion of the customized version as compared to the standard version; merging the customized version with the standard version to create a merged version of the program based on the identified common portions and the identified varying portions such that semantics of both the customized version and the standard version are preserved in the merged program; associating each change contributed by the customized version, represented by the varying portions in the merged version, to a defined extension point in the merged version; and generating a program extension for the standard version for each span of the program contained in a defined extension point span in the merged version. | 03-26-2015 |
20150106787 | ELASTIC APPLICATION FRAMEWORK FOR DEPLOYING SOFTWARE - Software is deployed to, and executed at, one or more computing devices in a computing system based on current conditions in the computing system and the capabilities of the different computing devices to handle the software. A request to run a software process calls a manager which determines an optimal place to run the software process. The manager can consider factors such as response time, user demands, bandwidth, processor utilization, storage utilization, security considerations, compatibility considerations and cost. Once a computing device is selected to run the software process, the manager facilitates movement of code and/or data to the computing device. | 04-16-2015 |
20150143337 | DEVELOPMENT OF MULTIPLE CLASSES OF USER INTERFACES FOR A SOFTWARE APPLICATION - Methods and systems for developing multiple classes of user interfaces for a software application are disclosed. A master view of a software application is displayed, at a computer system, for use in developing multiple classes of user interfaces for the software application wherein each of the multiple classes pertain to at least one form factor for a device to execute the software application. Subordinate views are created, at the computer system, wherein each of the subordinate views pertain to one of the multiple classes of user interfaces and comprise deltas that alter the master view such that a first subordinate view is displayed based on the master view combined with a first group of the deltas for the first subordinate view. A change is propagated to the master view to each of the subordinate views, at the computer system. | 05-21-2015 |
20150143338 | SPATIAL LAYOUT OF HIERARCHICAL SHARED RESOURCES - A hierarchical shared resources spatial visualization system and method including a visualization runtime user interface that quickly and efficiently displays a spatial layout of a shared resource having a hierarchical nature. The user interface provides a spatial layout of the hierarchical shared resource and overlays salient activity information of a group's interaction with the shared resource. In software development, the user interface provides software teams with awareness of activity by other developers in the group regarding files in the shared source code base. The salient activity includes active file information (such as which files are open and by whom) and source repository actions (such as a developer's activity within a project's source repository system). Visual geometry and colors are employed to create a visually distinctive environment that is used to convey the salient activity information quickly and efficiently. | 05-21-2015 |
20150301824 | VERSION CONTROL OF APPLICATIONS - An application development system allows developers of software system to manage infrastructure resources during the development and testing process. The application development system allows users to define application containers that comprise components including source code, binaries, and virtual databases used for the application. An application container can be associated with policies that control various aspects of the actions taken using the application container including constraints and access control. The application development system enforces the policies for actions taken by users for the application containers. The encapsulation of policies with the application containers allows users of the application containers to take actions including creating virtual databases, provisioning virtual databases, and the like without requiring system administrators to manage resource issues. | 10-22-2015 |
20150301825 | Decomposing a Generic Class into Layers - The domain of genericity of an existing generic class may be expanded to include not just reference types, but also primitive and value types even though some members of the existing class do not support the expanded genericity. A subdivided version of the class may be created that includes a generic layer including abstract versions of class members and a reference-specific layer that including non-abstract versions of class members that are abstract in the generic layer. The subdivided version of the class may also include information that indicates to which layer a class member belongs. Problematic methods (e.g., methods that have built-in assumptions regarding the domain of genericity) may be moved into the second, reference-specific, layer, thereby retaining compatibility with classes that currently instantiate or reference those methods, while still allowing use within the expanded domain of genericity. | 10-22-2015 |
20150317154 | CUSTOMIZATION MANAGER - A customization includes a name of a module of source code in an existing generic version of application software, a specific position within the module, and a name of a file which contains additional software. An existing customized version of the application software is then prepared, to execute the additional software in executing the existing generic version at the existing specific position. When a new generic version of the application software is received, the existing customization is displayed if applicable to a module in the new generic version, followed optionally by receipt of an update to the existing specific position. On indication of user approval, a new customized version of the application software is prepared, to execute the additional software in executing the module in the new generic version, at the existing specific position or at an updated specific position, which depends on the optional receipt of the update. | 11-05-2015 |
20150331690 | METHOD AND APPARATUS FOR ASSOCIATING INFORMATION - The present invention belongs to the information processing field and discloses a method and apparatus for associating information. The method for associating information comprises: obtaining identification information of a first content; associating the identification information of the first content with a second content, wherein the second content is created for the first content; obtaining identification information of a third content, wherein the third content is an updated version of the first content, the third content containing revision made according to the second content; and associating the identification information of the third content with the second content. With the method and system for associating information as provided by the present invention, contents of a plurality of versions can be managed and traced efficiently without a need to modify the existing code review flow. | 11-19-2015 |
20150365308 | AUTOMATIC TRANSFORMATION OF MESSAGES BETWEEN SERVICE VERSIONS - A method and system are provided for automatic transformation of messages between service versions. The method includes collecting message data of messages sent to two or more versions of a service. Message data is identified as relating to a version of a service. Relationships are inferred between structure and content of messages sent to different versions of a service, and message transformation rules are created based on the inferred relationships. | 12-17-2015 |
20150370555 | COMPOSITING DELTAS WHEN MERGING ARTIFACTS IN A VERSION CONTROL SYSTEM - Embodiments of the present invention address deficiencies of the art in respect to merging artifacts in a version control system and provide a novel and non-obvious method, system and computer program product for compositing deltas when merging artifacts in a version control system. In one embodiment, a method for compositing deltas for artifacts can be provided. The method can include generating deltas for a contributor artifact of an ancestor artifact, identifying interrelated ones of the deltas and grouping the interrelated ones of the deltas into a composited set of deltas. The method further can include rendering the composited set of deltas in a hierarchical view of a compare view for a version control data processing system in a development platform. | 12-24-2015 |
20150378871 | TECHNIQUES FOR EDIT-AND-CONTINUE AND ENHANCED OPTIMIZED DEBUGGING ON OPTIMIZED CODE - Methods, systems, and computer program products are provided that enable a portion of code to be marked in source code to disable compilation optimizations for the marked portion of code, while the rest of the source code is compiled with optimizations. In this manner, edit-and-continue debugging may be performed on the compiled source code in an enhanced manner. Modifications made to the marked source code (as well as the rest of the source code) may be compiled in an incremental manner, such that the portions of the source code affected by the modifications are compiled, while unaffected portions of the source code are not recompiled. | 12-31-2015 |
20160034273 | Attributing Authorship to Segments of Source Code - An electronic device accesses a comparison of at least a portion of a second version of a software program to a corresponding portion of a first version of the software program. The device determines an attribution value for a first author based in part on one or more differences between a respective segment of source code in the second version of the software and a corresponding segment of source code in the first version of the software, and determines an attribution value for a second author based in part on one or more differences between the respective segment of source code in the second version of the software and the corresponding segment of source code in the first version of the software. The device displays or sends instructions for displaying indicia of at least one attribution value with the respective segment of source code in the second version. | 02-04-2016 |
20160041822 | ADDING DIRECTIVES FOR VERSIONS OF SOURCE FILES DIRECTLY INTO SOURCE CODE - A version of the source file is created that includes source code from a source file, and at least a portion of a client-side scripting language file (CSSLF) for generating at least a portion of markup language for a web page to be served to a client device using a webserver. A processor associates metadata with a preprocessed directive (PPD) and a version of the source file (VSF). The metadata can include at least the portion of the CSSLF. The webserver can then retrieve, from a database, only the metadata associated with the PPD in the VSF such that the entire source file does not need to be retrieved. When a request for the metadata associated with the VSF is received, at least the portion of the markup language for the web page can be generated in accordance with the metadata associated with the PPD and the VSF. | 02-11-2016 |
20160048390 | METHOD FOR AUTOMATED MANAGING OF THE USAGE OF ALTERNATIVE CODE AND A PROCESSING SYSTEM OF OPERATING THEREOF - The present application relates to a method and a processing system for automated managing of the usage of alternative code. Code sections including original code and alternative code are retrieved from a code basis and the retrieved code is analyzed to detect an alternative code section. A condition definition associated with the identified alternative code section is further retrieved and the condition of the retrieved condition definition is evaluated. The identified alternative code section is activated in accordance with the evaluation result. | 02-18-2016 |
20160062765 | IDENTIFYING SEMANTIC DIFFERENCES BETWEEN SOURCE CODE VERSIONS - The present disclosure relates to a method and system for identifying a semantic difference between source code versions. In one embodiment of the present disclosure, there is provided a method for identifying a semantic difference between source code versions, comprising: obtaining first debugging information of a first source code version and second debugging information of a second source code version respectively; determining, by comparing the first debugging information with the second debugging information, whether in the second source code version there exists a second function matching a first function in the first source code version; and identifying the semantic difference on the basis of a result of the determining. In one embodiment of the present disclosure, there is provided a system for identifying a semantic difference between source code versions. By means of the present disclosure, a semantic difference between various source code versions can be identified rapidly and accurately. | 03-03-2016 |
20160070567 | GENERATING RELATED TEMPLATED FILES - The described technology is directed towards generating related templated files based on a set of data associated with to another class registered with a document system. These files may be edited into a source code file, a document file and a test file for any derived class. At runtime, which may include the runtime execution of the object based upon the test file, an object based upon the source code file is instantiated. Part of the object (e.g., a function) may be validated during the runtime based upon validation information in the document file. | 03-10-2016 |
20160070568 | AUTOMATIC CODE REVIEW AND CODE REVIEWER RECOMMENDATION - Systems and methods for managing review of source code are described. The method may comprise receiving a version of source code that includes a specific change at a specific location in the version of source code that has been affected by one or more programming actions compared to a prior version of source code; and identifying a plurality of prior review requests associated with the specific change. The method may comprise assigning corresponding review points to the plurality of prior review requests; and based on the corresponding review points, selecting a code reviewer from a plurality of code reviewers who each have created or processed a subset of the plurality of prior review requests. The method may further comprise generating a review request for the specific change in the version of source code for processing by the selected code reviewer. | 03-10-2016 |
20160077829 | DETERMINING SOFTWARE COMPLEXITY - Methods, apparatus, and computer program products for determining software complexity. A plurality of versions of a software module whose complexity is to be determined are compressed. Lengths of the compressed versions are compared, one with another, to provide complexity metrics. | 03-17-2016 |
20160110190 | Web Client Command Infrastructure Integration into a Rich Client Application - A command interface for a software application is implemented on a client computer. A first definition of the command interface is received from a server computer. The first definition includes rules for encoding the command interface on a web browser. A conversion of the first definition to a second definition is performed. The second definition includes language for encoding the command interface on a user interface of the software application. The second definition is used to render the command interface on the user interface of the software application. | 04-21-2016 |
20160132325 | VISUALIZING A CONGRUENCY OF VERSIONS OF AN APPLICATION ACROSS PHASES OF A RELEASE PIPELINE - A method for visualizing a congruency of versions of an application across phases of a release pipeline includes a selecting engine to select a phase from a number of phases; a representing engine to represent, via a user interface (UI), a congruency for a number of versions of an application compared against a target version of the application across the phases of a release pipeline, the congruency for the number of versions of the application represented with identifiers; a differentiating engine to differentiate a latest-deployed version of the application against a planned version of the application in a particular environment; and a comparing engine to compare, based on a selection, properties of the versions of the application. | 05-12-2016 |
20160132326 | SOURCE CODE VIOLATION MATCHING AND ATTRIBUTION - Methods, systems, and apparatus, including computer programs encoded on computer storage media, for matching and attributing code violations. One of the methods includes receiving a snapshot S of a code base of source code and a different snapshot T of the code base. Data representing first violations in the snapshot S and second violations in the snapshot Tis received. Pairs of matching violations are determined using performing two or more matching processes, including performing a first matching process, the first matching process determining first pairs of matching violations according to a first matching algorithm and performing a second matching process, the second matching process determining second pairs of matching violations according to a second matching algorithm from violations not matched by the first matching process. The first pairs of matching violations and the second pairs of matching violations are included in the determined pairs of matching violations. | 05-12-2016 |
20160139889 | MANAGING REUSABLE ARTIFACTS USING PLACEHOLDERS - Arrangements described herein relate to managing reusable artifacts. Responsive to receiving a request to create a placeholder for a reusable artifact representing a reusable unit, the placeholder for an appropriate version of the reusable artifact is created within a container and a first parameter identifying the reusable artifact is assigned to an artifact property of the placeholder. Responsive to receiving a request to pin a particular version of the reusable artifact to the placeholder, a version property of the placeholder can be updated to set the version, wherein the request to pin the particular version of the reusable artifact to the placeholder is implemented by assigning a value to a parameter in the placeholder or adding a pin property into the placeholder. The particular version can be maintained as the set version of the reusable artifact regardless of whether new artifact versions are created for the reusable artifact. | 05-19-2016 |
20160139890 | MANAGING REUSABLE ARTIFACTS USING PLACEHOLDERS - Arrangements described herein relate to managing reusable artifacts. Responsive to receiving a request to create a placeholder for a reusable artifact representing a reusable unit, the placeholder for an appropriate version of the reusable artifact is created within a container and a first parameter identifying the reusable artifact is assigned to an artifact property of the placeholder. Responsive to receiving a request to pin a particular version of the reusable artifact to the placeholder, a version property of the placeholder can be updated to set the version, wherein the request to pin the particular version of the reusable artifact to the placeholder is implemented by assigning a value to a parameter in the placeholder or adding a pin property into the placeholder. The particular version can be maintained as the set version of the reusable artifact regardless of whether new artifact versions are created for the reusable artifact. | 05-19-2016 |
20160139913 | SYSTEMS AND METHODS FOR INCREMENTAL SOFTWARE DEPLOYMENT - Methods and systems for facilitating incremental software deployment are disclosed. For example, a method can include receiving a command to deploy a second version of software to a computing system for execution on the computing system. In response to the command, differences between the second version of the software and a first version of the software being executed on the computing system are determined. Code changes to be made to the first version of the software to produce the second version of the software are determined based on the differences. The code changes to be made to the first version of the software are transmitted to the computing system. | 05-19-2016 |
20160139916 | Build Deployment Automation for Information Technology Mangement - A computer-executable mechanism captures code modifications for a computer-executable process from a development environment into build packages that may be deployed onto specified target environments with trace, audit, code compliance and rollback options from one single web portal. The mechanism supports build package code changes from different sources, automated test of the resulting build packages, and phantom source control of all packaged code base to reduce the burden on developers to manually source control code. The computer-executable mechanism supports a portal web server for building and deploying build packages to render user responses to configurable actions that may be passed on to a job sequencer to execute a series of jobs. A computer-executable roll-back mechanism takes a snapshot of the target environment prior to deployment of a build package so that a complete release rollback or an incremental release rollback may occur as needed. | 05-19-2016 |
20160162287 | AUTOMATIC GENERATION OF CERTIFICATE OF ORIGIN (COO) FOR SOFTWARE SYSTEMS - A system includes at least one computing device. The computing device has one or more processors, a memory, and a storage storing computer executable code. The computer executable code, when executed at the processors, is configured to process a plurality of source modules to generate a plurality of binary modules corresponding to the source modules. Each source module has at least one source file and a control file including a certificate of origin (COO) of the source module, and each binary module generated from each source module has at least one corresponding binary file and a copy of the control file. Once the binary modules are generated, the computer executable code combines the binary files of each of the binary modules to generate an executable file, and generates a COO file for the executable file based on the control files from the source modules or the binary modules. | 06-09-2016 |
20160162288 | TRANSITIVE SOURCE CODE VIOLATION MATCHING AND ATTRIBUTION - Methods, systems, and apparatus, including computer programs encoded on computer storage media, for matching and attributing code violations. One of the methods includes receiving a plurality of snapshots of a code base, including data representing a revision graph of the snapshots of the code base and data representing respective violations in each of the plurality of snapshots. A plurality of transitively matched violations in the code base are generated, wherein each transitively matched violation represents a respective sequence of matching violations from a first violation of a first snapshot to a second violation of a second snapshot, wherein each transitively matched violation identifies a respective first violation representing an initial occurrence of a coding defect in the code base and a respective second violation representing a last occurrence of the coding defect in the code base | 06-09-2016 |
20160170745 | TAGGING NON-UPSTREAM SOURCE CODE | 06-16-2016 |
20160170746 | EFFICIENT ANNOTATION SYSTEM FOR DISTRIBUTED VERSION CONTROL SYSTEMS | 06-16-2016 |
20160179511 | PARALLEL DEVELOPMENT OF A SOFTWARE SYSTEM | 06-23-2016 |
20170235568 | SOURCE CODE REVISION CONTROL WITH SELECTABLE FILE PORTION SYNCHRONIZATION | 08-17-2017 |
20170235664 | TRANSITIVE SOURCE CODE VIOLATION MATCHING AND ATTRIBUTION | 08-17-2017 |
20190146784 | DOCUMENTATION FOR VERSION HISTORY | 05-16-2019 |