| Entries |
| Document | Title | Date |
|---|
| 20080209398 | Methods and Apparatus for Authentication of Configuration Items Via Configuration Item Change Analysis - Techniques for authenticating one or more configuration items in an information repository are provided comprising the step of running an audit on the one or more configuration items in accordance with a change history of each of the one or more configuration items and one or more request for change identifiers. | 08-28-2008 |
| 20080244520 | DEVICE AND METHOD FOR AUTOMATICALLY CONFIGURING SOFTWARE - An automatic program configuring apparatus capable of facilitating maintenance management of a storage device even when software components stored therein increase in number is disclosed. The apparatus includes a database unit storing software configuration information and software components corresponding to individual items of software component arrangement information which are organized in a tree structure which is represented by a markup language with tags being uniquely definable by a user. The apparatus further includes a configuration information input unit for inputting the software configuration information from the database unit, an interface unit for acceptance of selection of components by the user while displaying a component selection screen based on the input software configuration information, a software component input unit for inputting from the database storage unit software components corresponding to the user's component selection result, and a generator unit for combining together the input software components to generate a software program. | 10-02-2008 |
| 20080244521 | Product Allocation Interface - A computer-implemented framework and method for maintaining product allocation data objects comprising a plurality of product allocation data objects, a plurality of software modules, an interface for the software modules, and a plurality of computer-applications, wherein the product allocation data objects are representative of product allocations for several participants within an e-business system, wherein a product allocation data object is processed by at least one of the plurality of computer-applications, the software modules providing access to the product allocation data objects, and the interface provides concurrent access to the software modules for online collaboration, wherein a collaborative planning process of the product allocation data objects is executed by the software modules and controlled by the applications. | 10-02-2008 |
| 20080256516 | Software Factory - 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, wherein 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, wherein 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. | 10-16-2008 |
| 20080263519 | Dynamic Configuration Files - A dynamic nature is added to configuration files so that various types of dynamic functions can be performed within them. Variables are utilized within the configuration files. Thus, it is possible to have parameters specified in one configuration file and a formula to which the parameters will be applied in another configuration file. This allows changing of the values in the parameter file without having to modify the formula file, thereby streamlining the modification process when changes need to be made. In addition, it provides the capability for cross-referencing between configuration properties by allowing for variables in properties that refer to other properties. | 10-23-2008 |
| 20080282228 | QUALITY MANAGEMENT FRAMEWORK FOR A SOFTWARE LIFECYCLE - A quality management framework (hereinafter referred as “framework”) for a software project lifecycle is provided. The framework enables generation of at least one software program while ensuring compliances with at least one standard. The plurality of items of the library includes tool an organization chart depository, a policy depository, a procedure depository, a life cycle model depository, a guideline depository, a template depository, a process asset depository, a workflow diagram depository and a checklist depository. Each of the items of the library is configured to be updated and accessed. The life cycle model depository of the library is configured to include a modular interface that enables handling of multiple lifecycle (V-model, waterfall model, iterative model etc.) models. The framework is configured to allow access the library. | 11-13-2008 |
| 20080301641 | Management of Heterogeneous Software Artifacts Through a Common Representation - A method for managing a configuration of heterogeneous software artifacts through a common central configuration representation includes adding a plurality of software artifacts from an initial software solution to a heterogeneous configuration tool. Using this heterogeneous configuration tool, artifact-level configuration parameters are extracted out of selected software artifacts by the heterogeneous configuration tool. The extracted artifact-level configuration parameters are then presented in a single representation. A subset of the presented extracted artifact-level configuration parameters is mapped to a set of solution-level parameters, which are then exposed in a subsequent software solution. Thereafter, parameters for one or more of the solution-level parameters, which are used by the subsequent software solution, are exposed. These parameters for the subsequent software solution are then mapped back to the artifact-level configuration parameters of the subsequent software solution. | 12-04-2008 |
| 20080301642 | Method and System for Dynamically Tracking Arbitrary Task Dependencies on Computers in a Grid Environment - A method, system and computer program product for tracking arbitrary task dependencies on computers in a grid environment including the steps of downloading a task to a computer coupled to the grid and identifying the dependencies necessary to perform the task and downloading the dependency executables to check the dependencies on the computer, and executing the downloaded dependency executables on the computer. When the dependencies are satisfied, executing the task on the computer and returning the results of the task to the grid server. When at least one of the dependencies are checked and are not satisfied on the computer, returning an error for the task to the grid server, recording the particular dependencies that failed as not satisfied for the computer, and recording a timestamp indicating when the dependency was checked. Assigning a task to a particular computer coupled to the grid if there are no recorded failed dependencies required for the task associated with the computer or the timestamp associated with a recorded dependency failure is of a predetermined age. | 12-04-2008 |
| 20080313615 | REMOTE SERVLETS COLLABORATION - Presents remote servlets collaboration. A method includes: creating a common registry; creating an extended context in response to an external request, wherein the extended context can invoke the resources within the common registry; performing initializing configuration on a plurality of servlets, and registering a plurality of servlets in the common registry, wherein a plurality of servlets being located on different Java virtual machines, or being located in different servlet containers on the same Java virtual machine; and a plurality of servlets collaborate with each other by being invoked through the extended context. It can implement collaboration between servlets located on different virtual machines or even servlets on the same virtual machine but within different servlet containers, because in a converged application service system, not only between HTTP servlets or between SIP servlets but also between HTTP servlets and SIP servlets there is necessity to collaborate. | 12-18-2008 |
| 20080320447 | METHOD OF ACCESSING WEB PARAMETERS - A method of accessing Web parameters includes: providing a first program code for managing at least one Web parameter, where the Web parameter is stored in a parameter set and the first program code is a light-weight program code; and when a second program code is executed, accessing the Web parameter stored in the parameter set by utilizing the first program code. | 12-25-2008 |
| 20090024984 | METHOD OF MANAGING APPLICATION SOFTWARE - When there is duplication between already installed applications on the one hand and applications included in integrated package software to be installed on the other hand, usage information that permits a user to use the duplicate application is output. The user is allowed to re-use the duplicate application identical to one of the already installed application, in accordance with the usage information. | 01-22-2009 |
| 20090031288 | EJECTION FAILURE MECHANISM - A system and method for an ejection failure mechanism is provided. The system receives a request to eject an ejectable resource, and, provides information associated with a failure of the ejection of the ejectable resource, if ejection of the ejectable resource is unsuccessful. The system thus provides a deterministic mechanism through which information associated with failure of the ejection of an ejectable resource can be communicated. As such, an initiator of the request to eject can receive information associated with a cause of the ejection failure. | 01-29-2009 |
| 20090037879 | METHOD AND SYSTEM FOR INTEGRATING MODEL-BASED AND SEARCH-BASED AUTOMATIC SOFTWARE CONFIGURATION - Techniques are disclosed for integrating a model-based approach with a search-based approach for automatic configuration of a computer system. For example, in one such technique, a method for automatically configuring at least one computer system includes obtaining at least one model describing one or more effects of at least one configuration parameter on a behavior of the computer system, and modifying a process for searching for at least one acceptable value for the configuration parameter based on the model. | 02-05-2009 |
| 20090037880 | SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT FOR CONFIGURING A GOAL - A system, method, and computer program product are provided for configuring a goal. Information associated with different aspects of a goal is received utilizing a plurality of graphical user interfaces. In use, a previous one of the graphical user interfaces progresses to a subsequent one of the graphical user interfaces only after receiving the information associated with the aspect associated with the previous one of the graphical user interfaces. To this end, the goal is configured utilizing such information. | 02-05-2009 |
| 20090044173 | AUTOMATIC COMPUTING SYSTEM, EXECUTION ENVIRONMENT CONTROL - To realize an autonomic system and method of improving the quality of a piece of software and solving problems with respect to operations in stages of a software life cycle. There are provided a pattern catalog | 02-12-2009 |
| 20090064108 | Configuring Software Stacks - The present disclosure is directed to a system and method for configuring software stacks. In some implementations, a method for configuring devices includes automatically identifying one or more applications in the software stack based, at least in part, on at least one of a plurality of identifiable device models or types. The software stack is stored in a device. The one or more applications is automatically configured for execution in the device in accordance with the identified device model. Each of the plurality of identifiable device models is associated with a different configuration of the software stack. | 03-05-2009 |
| 20090083711 | METHOD AND APPARATUS FOR ENABLING COLLABORATIVE PRODUCT DEVELOPMENT PROCESSES - A computer-implemented method supporting collaborative product development. A plurality of artifacts associated with the collaborative product development is maintained under revision control in a first repository. Each artifact has a plurality of lifecycle states and each artifact is associated with a first finite state machine (FSM) that defines lifecycle state transitions for the artifacts. A plurality of artifact tuples associated with the collaborative product development is maintained under revision control in a second repository. At least one artifact tuple is comprised of at least one access information providing access to at least one of said plurality of artifacts in the first repository. Each artifact tuple has a plurality of lifecycle states and each artifact tuple is associated with a second finite state machine (FSM) that defines lifecycle state transitions for the artifact tuples. There exists a set of lifecycle state transition mappings which maps all valid lifecycle state transitions for an artifact with desired lifecycle state transitions for an artifact tuple and all valid lifecycle state transitions for an artifact tuple with desired lifecycle state transitions for an artifact. A workflow process relating to an evolution of an artifact or artifact tuple is expressed through sequencing of one or more members of the said lifecycle state transition mappings set. | 03-26-2009 |
| 20090089753 | SOFTWARE PRODUCT LINE ANALYZER - A software-product line analyzer including change history data, a change-history processing unit, a factor analysis unit, a variability analysis unit, and configuration information data, i.e., output data, wherein the change-history processing unit converts the change history data into numerical values, the factor analysis unit performing a factor analysis using inter-products change information as observation data, and, based on each factor and each factor score determined, the variability analysis unit determining variabilities in the software-product line and software components corresponding thereto, and outputting the configuration information data. | 04-02-2009 |
| 20090119643 | METHOD, SYSTEM AND COMPUTER-USABLE MEDIUM FOR TRACKING AND RECORDING MODIFICATIONS TO A SOFTWARE SOLUTION - 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. | 05-07-2009 |
| 20090144700 | METHOD AND SYSTEM FOR PREPARING SOFTWARE OFFERINGS HAVING SOFTWARE APPLICATION CODE AND POST-INSTALL CONFIGURATION INFORMATION - Embodiments relate generally to a method of generating a post-installation configuration for a software application offering. The method includes receiving a request for a post-installation configuration for a software application and determining a software distribution in which the software application will operate. The method also includes determining a set of inter-dependencies between the software application and the software distribution and retrieving a set of templates for post-installation configuration of the software application. The method further includes generating a post-installation configuration file that customizes the software application for operation with the software distribution and packaging the software application into an offering that comprises the post-installation configuration file and the software application. | 06-04-2009 |
| 20090144701 | METHODS AND SYSTEMS FOR PROVIDING CONFIGURATION DATA - Systems and methods provide real time and interactive software configuration. A configuration support module is configured to provide configuration data associated with software being configured by a user. The configuration support module is configured to store configuration data associated with different entities related to users. The entities can be a company, organization, corporation, association, and the like related to the users. The configuration support module can store configuration data that is common to different users related to the entity. | 06-04-2009 |
| 20090144702 | System And Program Product for Determining Java Software Code Plagiarism and Infringement - An analysis tool extracts class data from Java objects within a potential plagiarizing Java program and the original Java program, and then compares classes common to the potential plagiarizing program and the original across various performance metrics. Similarities disclosed by the analysis tool are output for user or programmatic comparison of the matches between the potentially plagiarizing Java program byte code and the original program's byte code. | 06-04-2009 |
| 20090172640 | Medical Device With Full Options and Selective Enablement/Disablement - According to one embodiment, a programmable medical device includes a storage means for storing a plurality of software modules operable to control one or more medical functions of the device. The device is configured to receive a plurality of commands. An operational state of each of the software modules is configured to be controlled according to a respective one of the commands. | 07-02-2009 |
| 20090204944 | GENERIC XAD PROCESSING MODEL - Embodiments are directed to dynamically building software applications and dynamically updating software applications based on changed data values. In one embodiment, a computer system receives an indication that a software application is to be initiated. The computer system also receives an application description including tags describing software objects that are to be included in the software application, automatically maps portions of the application description identified by the tags to software objects using reflection, where the reflecting includes accessing properties associated with the software objects, and automatically binds properties of the software objects to the portions of the application description based declarative rules included in the software object properties associated with the software object. | 08-13-2009 |
| 20090210858 | METHOD AND APPARATUS FOR GENERATING VIRTUAL SOFTWARE PLATFORM BASED ON COMPONENT MODEL AND VALIDATING SOFTWARE PLATFORM ARCHITECTURE USING THE PLATFORM - A method and apparatus for validating a component model-based software platform architecture, the method including: generating a virtual software platform having a template code describing functions of one or more components of software according to design information of a software platform and a build script having configuration variables according to a type of the software and building the generated template code; changing the configuration values of the configuration variables provided in the virtual software platform for a combination of the components; and validating a consistency of the software platform according to a result of executing the virtual software platform based on the changed configuration variables. According to the method and apparatus, by validating in advance whether it is possible to construct a normal composition of the software product, testing and manpower costs can be reduced. | 08-20-2009 |
| 20090259991 | METHOD AND APPARATUS FOR PROCESSING CONFIGURATION INFORMATION AND A PLATFORM SYSTEM - A configuration information processing method includes: receiving a policy identifier sent by a user, where the policy identifier represents the configuration information which the user requests to obtain; obtaining the source information and combination policy information according to the policy identifier; searching for the corresponding configuration sources according to the source information; and combining the configuration sources into a uniform configuration source according to the combination policy information. A configuration information processing apparatus includes: a policy identifier receiving unit, an information obtaining unit, a configuration source querying unit, and a configuration source combining unit. A platform system includes: a user operation interface, a configuration information processing apparatus, and a configuration generating unit. The configuration generating unit is adapted to develop or customize platform configuration information requested by the user according to the combined uniform configuration source. The embodiments of the present disclosure improve the flexibility of platform customization effectively, and implement upgrade and customization of platform products conveniently. | 10-15-2009 |
| 20090265687 | SYSTEM AND METHOD FOR UPDATING INITIALIZATION PARAMETERS FOR APPLICATION SOFTWARE FROM WITHIN A SOFTWARE DEVELOPMENT ENVIRONMENT - A computer implemented method for updating initialization parameters for application software from within a software development environment. The method involves changing a value of at least one initialization parameter contained in a configuration file of a developer computer system. The method also involves starting application software deployed on an application server in response to the value change. Thereafter, the configuration file including the changed value of the initialization parameter is communicated from the developer computer system to the application server. Once the configuration file is received at the application server, the application software is initialized using the configuration file. | 10-22-2009 |
| 20090276757 | Systems and methods for inference and management of software code architectures - Systems, computer program products, and methods for extracting, evaluating, and updating the architecture of a software system are provided. In an embodiment, the method operates by defining the planned architecture for the system and extracting the implemented software code architecture from the source code of the system. The method compares the actual architecture to the planned architecture defined to identify architectural deviations, and suggested changes to the architecture are identified based upon the architectural deviations. The modeled code architecture and defined planned architecture information enables verification and determination of whether a software system's source code conforms to the intended structure of the system. The code architecture and planned architecture comparison also enables analysis and display of the effects that changes to source code may have on the structure of a software system. | 11-05-2009 |
| 20090288069 | Dynamic Declarative Application Description - Embodiments described herein are directed to dynamically reconfiguring at least a portion of an operating software application. In one embodiment, a computer system receives an edit indicating that at least one portion of an operating software application is to be edited, where the edit includes changes that are to be dynamically applied to the application. The computer system instantiates dynamic configuration builders designed to implement application changes as indicated by the received edit and determines which portions of the application are to be suspended while the changes to the application are implemented. The computer system suspends the determined application portions until the application changes are implemented and implements the changes indicated by the edit on the suspended portion of the application, while the remainder of the application continues operating. The computer system also dynamically reconfigures the application with the implemented changes, where the reconfiguring includes reinitializing the suspended application portions. | 11-19-2009 |
| 20090300584 | METHODS AND SYSTEMS FOR PROVIDING A DEMO APPLIANCE AND MIGRATING THE DEMO APPLIANCE TO A PRODUCTION APPLIANCE - An appliance support module can be configured to receive a request to build a demo software appliance from a user. The appliance support module can be configured to build the demo appliance and to include configuration data in demo software appliance. The appliance support module can be configured to receive a request to migrate the demo software appliance to a production software appliance. The appliance support module can be configured to migrate the demo software appliance by modifying the configuration data in order to provide full functionality to the demo software appliance that was previously limited. The appliance support module can also receive a request to scale the production software appliances. The appliance support module can scale the production software appliance by dividing the applications contained in the production software appliances into separate software appliance. | 12-03-2009 |
| 20090319992 | CONFIGURABLE PARTITIONING FOR PARALLEL DATA - A data partitioning interface provides procedure headings to create data partitions for processing data elements in parallel, and for obtaining data elements to process, without specifying the organizational structure of a data partitioning. A data partitioning implementation associated with the data partitioning interface provides operations to implement the interface procedures, and may also provide dynamic partitioning to facilitate load balancing. | 12-24-2009 |
| 20090319993 | GENERALIZED AND EXTENSIBLE SOFTWARE ARCHITECTURE REPRESENTATION - Software architectures may include many types of elements, such as classes, functions, databases, queries, and users. An architecture may be the subject of many types of analysis, such as discovery of architecture features and design choices, rendering according to (e.g.) a visual layout or as a hierarchical data set, validation and testing of a chosen design, and evaluation by systems analysis tools. However, the information documenting the software architecture is often organized in a disjointed manner, such as in a set of release documentation, inline comments in source code, notes recorded in version control systems, and contact databases. Instead, the software architecture may be represented as a set of nodes of various node categories interconnected by links of different types. The representation may then be utilized in many types of analysis, such as visualization, transformation, and element analysis by complex systems analysis tools. | 12-24-2009 |
| 20100005450 | SOFTWARE PACKAGE MANAGEMENT - Apparatus, systems, and methods may operate to receive a request to roll back one or more individually specified software packages to their respective package states at a prior time on a processing system, to determine a series of transactions on the processing system associated with the individually specified software packages and their dependencies, conducted between the current time and the prior time, and to roll back the dependencies and the individually specified software packages to the respective package states on the processing system. Additional apparatus, systems, and methods are disclosed. | 01-07-2010 |
| 20100005451 | POLICY APPLICATION RULES FOR AUTOMATED CONFIGURATION OF SOFTWARE COMPONENTS - A method, system and article of manufacture are disclosed for configuring software application components. The method comprises the steps of developing a set of policy application rules, assembling unconfigured software components into one or more software applications, and applying said application rules to the unconfigured software components to configure said software components. In the preferred embodiment, the applying step includes the steps of passing the unconfigured software components to a policy rule engine, and using said policy rule engine to apply said application rules to the unconfigured software components to produce the configured components. In addition, the method may be done to resolve ambiguities in the software components. In particular, the application rules may be designed to resolve ambiguities in the application of these rules to the unconfigured software components. Also, each application rule preferably includes a condition, an application template, and a policy. | 01-07-2010 |
| 20100005452 | Methods and systems for factory configuration of existing customer system settings - Methods and systems are described for factory configuration of existing customer settings so that existing customer settings can be easily configured or pre-configured on new information handling systems. A software module is run on a first information handling system that captures configuration information for an existing information handling system. One example for such configuration information is network configuration information associated with one or more existing wireless and/or wired networks on which a new information handling system will operate. Captured configuration information is transferred to a server information handling system associated with ordering of the new information handling system. The transferred configuration information is then used to configure the new information handling system. | 01-07-2010 |
| 20100005453 | APPLIANCE DEVELOPMENT TOOLKIT WITH EDITOR TO CREATE SHARED VARIABLE NAMESPACE - An appliance development toolkit according to the invention is provided to enable creation of content to affect operation of a component in an appliance or to affect user interaction with an appliance. The toolkit comprises an editor configured to enable creation of a variable holder, to associate the variable holder with a variable, to create a value holder related to a valid value of the variable, and to associate the variable holder with the value holder. A user can use either of the variable holder or the value holder in creating a hierarchy of elements for content independent of any relationship that may otherwise exist between the variable and other elements and between the value and other elements. With this structure, the variable and the value can be used in different contexts with different relationships while maintaining their relationship with each other by way of the variable holder and the value holder. | 01-07-2010 |
| 20100011343 | REMOTE PRODUCT INVOCATION FRAMEWORK - A method for remote product invocation includes configuring an invocation framework that includes an integration module and an endpoint/handler module. Once configured, the integration module is configured to: receive a source object; format data from said source object for a desired operation; and utilize said endpoint/handler module to make a connection to an external service that executes said desired operation using said data from said source object. A system for remote invocation of external services includes a calling entity which generates a source object containing data for execution of a remote operation; and an integration module configured to receive the source object, interpret the source object, and pass the data to an endpoint/handler which opens a connection with an external service and executes the remote operation. | 01-14-2010 |
| 20100031237 | Methods for Detecting Inter-Module Dependencies - Methods for detecting inter-module dependencies involve receiving by a software configuration control system check-in for each of a plurality of software components accompanied by check-in information consisting at least in part of defect information, which is utilized to identify coupling between any of the checked-in software components that were checked in together on a same defect and any of the checked-in software components that were checked in on a defect that was introduced by a defect in another software component. Warnings and reports are generated of a likely incidence of coupling between any of the software components identified as having been checked in together on a same defect, as well as between any of the software components identified as having been checked in on a defect that was introduced by a defect in another software component and such other software component. | 02-04-2010 |
| 20100037207 | APPARATUS, SYSTEM AND METHOD FOR INTEGRATED CUSTOMIZATION OF MULTIPLE DISK IMAGES INDEPENDENT OF OPERATING SYSTEM TYPE, VERSION OR STATE - An apparatus, system, and method are disclosed for customizing a disk image. A base image is booted and the desired customizations are applied and captured using a known method. A maintenance environment is booted and a builder module incorporates the captured customizations into an integrated package. If user input is required then custom menus are also defined. A target operating system, independent of the base image, is hooked to invoke an injector module. The operating system is booted from the maintenance environment thereby invoking the injector module. The customizations from the integrated package together with any obtained from the custom menus are injected into the operating system. A customized image of the operating system is then saved, to be deployed to other computers or further customized as required. | 02-11-2010 |
| 20100042974 | BUILD OPTIMIZATION WITH APPLIED STATIC ANALYSIS - A method of constructing a software build using a static structural analysis system is disclosed. A software build configuration may be run and analyzed by a software analyzer to detect dependencies among code classes and components. A code dependency map is constructed identifying code level dependencies. The code dependency map may be referenced for code classes and components selected for modification. Identified dependency relationships with the selected code classes and components enable a builder to rebuild those code classes and components affected by the modification. Additionally, the software analyzer may identify undesirable dependencies and anti-patterns in potential need of deletion or modification. | 02-18-2010 |
| 20100083230 | Data Feature Tracking Through Hierarchical Node Sets - A data set may be represented as a hierarchical node set, comprising interrelated nodes that respectively include various data features (e.g., versions in a version-controlled software architecture.) Queries may be formulated regarding the inclusion of a particular feature in the nodes of the hierarchical data set (“does this node include this data feature?” and “what is the path of the data feature through the node set?”). Such queries may be evaluated by identifying a source node that includes the data feature, identifying candidate merge paths from the source node to the taget node, and determining whether the nodes of any candidate merge path include the data feature. The results may be presented to the user, e.g., as a visual layout of the portion of the hierarchical node set that includes the data feature or a timeline of nodes illustrating the path of the data feature over time. | 04-01-2010 |
| 20100100870 | CONFIGURATION DEPLOYMENT MANAGEMENT - Applications, code modules, and other such software objects are able to be deployed and/or ported even when the corresponding configuration data is spread between a relational database management system (RDBMS) database and a meta data services (MDS) database, even where the configuration data is spread across any disparate databases. Configuration data also can be stored in a custom repository, such as an custom extensible markup language (XML) file. One approach involves detecting foreign keys, creating logical references to replace the foreign keys, and resolving the foreign keys to new references in the deployed environment by using the logical references. Code can be stored in the databases in order to help resolve the foreign keys. | 04-22-2010 |
| 20100125830 | Method of Assuring Execution for Safety Computer Code - A method and apparatus for preventing inadvertent execution of a segment of computer code is contemplated. One or more allowed executors are associated with each code segment. Each code segment is adapted to autonomously compare an originating code segment to each of the allowed executors to determine if it has been appropriately invoked. When a match is found execution will be allowed to continue, however, when a match is not found the code segment will take appropriate action such as blocking continued execution. In this way inadvertent execution of the code segment is prevented. | 05-20-2010 |
| 20100146484 | 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. | 06-10-2010 |
| 20100153917 | SOFTWARE CONFIGURATION CONTROL WHEREIN CONTAINERS ARE ASSOCIATED WITH PHYSICAL STORAGE OF SOFTWARE APPLICATION VERSIONS IN A SOFTWARE PRODUCTION LANDSCAPE - According to some embodiments, a source version of a software product may be established in connection with a software production landscape. A first container, representing a first uniquely addressable physical location in the software production landscape, may then be associated with the source version. An executable derivative version of the software product may be built from the source version, and a second container, representing a second uniquely addressable physical location in the software production landscape, may be associated with the executable derivative version. Software configuration information may then be automatically provided to a user based at least in part on a relationship between the first and second containers at a given point in time. | 06-17-2010 |
| 20100153918 | 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. | 06-17-2010 |
| 20100169865 | Selective Notifications According to Merge Distance for Software Version Branches within a Software Configuration Management System - A computer-implemented method of controlling version branching within a software configuration management system (SCMS) can include, responsive to a user initiating a check-out operation of a file within the SCMS, identifying the file and a workspace of the user and searching nodes of the repositories of the SCMS for a successor version of the file. When a successor version of the file is located within a node that is within a predetermined distance of the workspace of the user, a notification that the successor version of the file is within the predetermined distance of the workspace of the user can be output. When a successor version of the file is not located within a node within a predetermined distance of the workspace of the user, the file can be checked-out to the workspace of the user. | 07-01-2010 |
| 20100192126 | INFORMATION PROCESSING APPARATUS, EXECUTABILITY DETERMINING METHOD, AND COMPUTER PROGRAM FOR THE SAME - An information processing apparatus is described which includes a list fetching section for fetching, from outside, a list of disabled contents information indicating disabling execution of an application program, when the contents data is subjected to a contents data reproducing/copying process for at least reproducing or copying the contents data. When it is determined that a type and/or a version of the application program identified by referring to the starting file corresponds to a type and/or a version of any disabled application program described in the list of disabled contents information, the starting file is not distributed to the application program. | 07-29-2010 |
| 20100192127 | SYSTEM AND METHOD FOR A SOFTWARE PRODUCT MANAGER - A component-based software product manager system and method are provided. Various software products for electronic appliances include common components that are shared there between and variable components that are not commonly shared there between and instead are exclusive to individual products. The component-based software product manager system and method combine and associate components with one another while managing a large-scale software asset in units of the components. The system and method described herein improve the cooperation and the reusability of software products. | 07-29-2010 |
| 20100235813 | METHOD AND SYSTEM FOR CONFIGURING SOFTWARE MODULES TO EXECUTE IN AN EXECUTION ENVIRONMENT - A method for configuring software modules that includes accessing a properties repository that includes a plurality of properties of the execution environment of the computer system. The method further includes generating a configuration file for each software module. Generating a configuration file includes obtaining a generator module defined for the software module, and executing the generator module to instantiate the configuration file for the software module. The generator module is configured to identify a property required for the configuration file, obtain the value for the property from the properties repository, and store the value for the property in the configuration file in accordance with a customized format required by the software module. The method further includes storing the configuration file for each of the software modules. | 09-16-2010 |
| 20100287533 | SYSTEM AND METHOD FOR PROVIDING A PARAMETER FOR AN APPLICATION OPERATING ON AN ELECTRONIC DEVICE - The disclosure relates to a system, method and device for modifying a parameter for an application operating on an electronic device. The method comprises the steps of: (a) upon activation of the device, determining a state of initial configuration for the device; (b) if the state indicates that the device requires configuration, providing a GUI interface allowing for changes to be made to the parameter; and (c) if a change is made to the parameter through the interface, updating a storage location with the change. In the method, the device may have communication capabilities with a network; and time zone information relating to the location of the device may be provided from the network or from the device; and the time zone information may be used to update an aspect relating to the parameter. | 11-11-2010 |
| 20100299653 | SERVICEABILITY AND CONFIGURATION MANAGEMENT - Many current computer software platforms support user customization and version upgradability. Unfortunately, upgrading a computer software platform may result in significant loss of user customization data. Additionally, it may be advantageous for users to export and import their customization data to share as customized business solutions with other instances of the computer software platforms. Accordingly, a technique for creating and importing a configuration package and a technique for creating and utilizing an update package is disclosed herein. The configuration package allows configuration data of elements within a computer software platform to be exported and imported. The update package allows elements to be exported within the update package. The update package may be utilized in upgrading, overwriting, and/or creating a new instance of elements. When an existing element is upgraded with an update element within the update package, the existing element's original configuration may be retained. | 11-25-2010 |
| 20100333067 | PROCESS-DRIVEN FEEDBACK OF DIGITAL ASSET RE-USE - Methods, systems and computer program products for process driven feedback of digital asset reuse. Exemplary embodiments include a method for process-driven feedback for a digital asset, the method including identifying the asset downloaded in a computer system from a repository operatively coupled to the computer system, and for a current project within the computer system for the current project, determining whether the asset has been consumed within the current project, determining feedback and changes between the asset prior to the current project and after the current project, consolidating the feedback and the changes associated with the asset and automatically generating feedback for the asset repository so that the feedback and changes are associated with the asset for comparison in a future project similar to the current project. | 12-30-2010 |
| 20110023018 | SOFTWARE PLATFORM AND METHOD OF MANAGING APPLICATION INDIVIDUALS IN THE SOFTWARE PLATFORM - A component-based system plane software platform is provided and the software platform includes an individual identifier manager to assign an individual identifier to each object of an application that is executed in a distributed computing environment and to manage the individual identifier, and an instance provider to create an instance for a service object in response to a request from the application and to provide the instance to the application. The software platform may systematically and effectively manage and control applications of system software under a component-based system software architecture to which a container model structure is applied. | 01-27-2011 |
| 20110078658 | OPERATION SUPPORT IN VERSIONING SYSTEMS - Implementations of the present disclosure provide a computer-implemented method that includes accessing computer code from a repository at a computer, registering a plurality of operations on the computer code at the computer, generating a changelist based on the operations, the changelist comprising a plurality of computer code objects affected by the operations, initiating a reversion operation to revert one or more of the computer code objects to a previous state, partitioning the computer code objects to provide independent first and second partitions, the first partition including an object set based on the computer code objects, and executing the reversion operation based on only the first partition including the object set. | 03-31-2011 |
| 20110083120 | MODELING AND LINKING DOCUMENTS FOR PACKAGED SOFTWARE APPLICATION CONFIGURATION - One or more document templates defining deployment procedures associated with deploying a packaged software application are obtained. One or more objects are created representing the one or more document templates and one or more elements of the one or more documents, and one or more links between the one or more objects are created. The one or more links represent one or more relationships between the created one or more objects. The one or more objects and the one or more links may be stored and/or output in a selected format. | 04-07-2011 |
| 20110107299 | SYSTEMS AND METHODS FOR INTEGRATED PACKAGE DEVELOPMENT AND MACHINE CONFIGURATION MANAGEMENT - Embodiments relate to systems and methods for integrated package development and machine configuration management. In aspects, a stage management engine can be invoked by a developer to initiate the development, testing, and deployment of a software package, e.g. an application or operating system. A set of repositories can store related versions of the software under development at different stages of building, testing, and deployment. The repositories can enforce consistent file naming and avoid duplication of stored files. In embodiments, the stage management engine can likewise interface with a configuration management database that stores and manages a resource configuration state of a host virtual machine used to develop and run the subject software package. Both the package and virtual machine bed can be moved through various development stages to production in coordinated fashion, ensuring consistency in both the software to be installed and the target machine for the installation. | 05-05-2011 |
| 20110107300 | SYSTEMS AND METHODS FOR UTILIZING A HISTORY OF CHANGES ASSOCIATED WITH SOFTWARE PACKAGES AND CONFIGURATION MANAGEMENT TO MANAGE MULTIPLE COMPUTING SYSTEMS - An administrator system can utilize a history generated by a tagging tool to determine the current configuration of computing systems. The administrator system can utilize the current configuration to verify that the computing systems have been configured properly and verify, over time, that the computing systems maintain the desired configuration. The administrator system can compare the current configuration with the desired configuration for the computing systems. | 05-05-2011 |
| 20110107301 | SELECTIVE DELTA VALIDATION OF A SHARED ARTIFACT - An illustrative embodiment of a computer-implemented process for selective delta validation of a shared artifact receives a notification associated with a shared artifact, determines whether a unique key exists for the shared artifact in a symbol data structure, and responsive to a determination that the unique key exists, determines whether an update from an external source occurred. Responsive to a determination that the update occurred from an external source, receives a timestamp associated with the unique key from the symbol data structure to form a received timestamp, determines whether the received timestamp is prior to a last modification time, and responsive to a determination that the received timestamp is prior to the last modification time, performs a delta validation of the shared artifact. | 05-05-2011 |
| 20110107302 | METHOD AND SYSTEM FOR MANAGING LIFECYCLE OF OBJECTS - A method, system and computer program product for managing the lifecycle of an object, where the lifecycle involves a plurality of states of the object, at least one transition between the plurality of states and at least one role who has authority to execute the at least one transition. At least one of the plurality of states, the at least one transition and the at least one role is mapped to Web Ontology Language (OWL) elements. The role related control information is obtained using the reasoning ability of OWL itself according to the above mapping. Furthermore, the lifecycle is managed according to the above role related control information. Using the principles of the present invention, the access control information of roles can be embedded into the lifecycle description and therefore the lifecycle management can be realized easily. | 05-05-2011 |
| 20110113404 | DEVICE AND METHOD FOR OPERATING COMMON MODULE IN SOFTWARE ARCHITECTURE - A device for operating a common module in a software architecture efficiently operating a software module using a closed M/G/1 queuing model of an extended form and a concept of a super-reserve module, and a method thereof are provided. The device includes a plurality of common modules for operating an application module, a plurality of backup modules for substituting for a crashed common module; and a module generating unit for substituting one of the plurality of backup modules for the crashed common module and for generating an additional plurality of backup modules when the plurality of backup modules are all substituted. | 05-12-2011 |
| 20110131549 | CENTRAL CONFIGURATION AND TRANSPORT SUPPORTING SOFTWARE LIFECYCLES - Implementations of the present disclosure provide computer-implemented methods including retrieving a predefined configuration model from a plurality of predefined configuration models electronically stored in a configuration repository, the predefined configuration model providing predefined configuration data for a particular software application, comparing the predefined configuration data to existing configuration data of one or more target systems to generate a first delta, a first system landscape including the one or more target systems, determining one or more configuration actions based on the first delta, and executing the one or more configuration actions to update a configuration state of the one or more target systems from an initial configuration state. | 06-02-2011 |
| 20110145788 | BRIDGING CODE CHANGES AND TESTING - Method and system for testing software code comprising determining code elements in software code, determining changed code elements in the software code, determining dependencies between code elements, determine dependency changes between code elements based on the determined changed code elements, determining an impact factor for the respective changed code elements based on the determined dependency changes, determine a test relevancy ranking for code tests based on the determined impact factor, selecting tests for the software code based on said test relevancy ranking, and performing the selected tests on the software code. | 06-16-2011 |
| 20110145789 | APPLICATION CONFIGURATION DEPLOYMENT MONITOR - Various embodiments include at least one of systems, methods, and software for monitoring application instance configurations and deployments. One such embodiment, in the form of a method includes executing, on at least one processor, an application deployment process to deploy at least one set of configuration settings stored in a memory device of an application configuration environment to an application instance in an application execution environment. The method may also include writing and storing data to a deployment log representative of application deployment process actions performed and an indicator of success of each of the performed actions. The deployment log data may then be retrieved from the data storage device and a view may be generated and presented providing a summary of actions performed and actions that were not successful. Other embodiments are described herein. | 06-16-2011 |
| 20110161931 | AUTOMATED STREAM-BASED CHANGE FLOWS WITHIN A SOFTWARE CONFIGURATION MANAGEMENT SYSTEM - Using stream-based change flow models to propagate source code file changes within a software configuration management system can begin with the detection of the addition of a source code file, either a new file or new version, to a software configuration management system by a change flow manager. The source code file can then be related to a component based upon the hierarchical placement of the source code file within the filesystem. Stream-based change flow models that contain the component can be identified. Change flow relationships within a stream-based change flow model can define the propagation of changes between streams (an aggregate of components) and/or components. Authorization from a human agent can be requested to initiate propagation of the source code file. Upon receipt of an affirmative response, the source code file can be automatically copied to the container objects that correspond to the identified recipients for changes. | 06-30-2011 |
| 20110167408 | CONFIGURABLE SOFTWARE APPLICATION - A configurable software application is provided, where the software application may be designed on a platform including at least one configuration utility for enabling end users to customize various aspects of the application. For example, end users may use the configuration utility to customize one or more user interface elements, event handlers, data handlers, and/or data elements of the application. The software application may be automatically updated to incorporate the user customizations. In one implementation, custom user interface elements may be used to control a navigation of the application or an interaction with data elements of the application. In another implementation, custom data elements, based on a hierarchical metadata structure, may dictate an organization of the application. In another implementation, custom event handlers may control business logic and rules for the application, while custom data handlers may control interfacing with the data elements. | 07-07-2011 |
| 20110209118 | METHODS AND SYSTEMS FOR OPEN SOURCE COLLABORATION IN AN APPLICATION SERVICE PROVIDER ENVIRONMENT - A system and method for integrating a plurality of web-based applications with a web-based file management system. The web-based application may provide a service to the users of the web-based file management system, such that the web-based application can interact with the files of said users. The integration of the service of the web-based application with the web-based file management system is achieved through a simple web interface to configure the service, without the developer of the web-based application having to change the application programming interface (API) of the application. The user of the web-based file management system may add services of a plurality of available web-based applications and use these services with one or more files that are stored on the web-based file management system. | 08-25-2011 |
| 20110219358 | EXTENSIBLE FRAMEWORK FOR COMPATIBILITY TESTING - A method of receiving mobile code includes receiving, from a source node, a dependency descriptor describing at least one permitted configuration, each configuration comprising necessary conditions on a destination node to execute mobile code, executing, on the destination node, checker code associated with the conditions described in the dependency descriptor, and, if at least one configuration is compatible, receiving the mobile code at the destination node. | 09-08-2011 |
| 20110239189 | SOFTWARE MANAGEMENT SYSTEM FOR NETWORK DATA PROCESSING SYSTEMS - A method, data processing system, and computer program product are presented for planning upgrades to a network data processing system. A processor unit identifies configuration information for hardware and software programs for a plurality of computers in the network data processing system. The processor unit obtains end of life dates for the software programs, release dates for the replacement software programs, and prerequisites for replacement software programs for the software programs identified in the configuration information. The processor unit identifies at least one change to the plurality of computers based on the configuration information and a set of prerequisites in the prerequisites for each of a plurality of replacement software programs for a plurality of software programs in the software programs. The processor unit generates at least one upgrade plan to implement at least one change to the plurality of computers in which a number of overlaps between life cycles for the plurality of replacement software programs and life cycles for the plurality of software programs in the software programs is increased. | 09-29-2011 |
| 20110239190 | Method for Customizing Software Applications - Techniques for overlaying objects of a software application with other objects allow modification and customization of the application by one or more users in different ways, without storing multiple modified copies of the application. The technique allows configuring the software application to execute using overlaid objects instead of the base objects contained in the software application. In some embodiments, the base objects for the software application and the overlaid objects are stored in a datastore, and a runtime embodiment causes execution of the overlaid objects instead of the base objects. | 09-29-2011 |
| 20110239191 | Method for Providing Assistance in Making Change Decisions in a Configurable Managed Environment - In a configurable managed system having an associated CMDB, a Change Manager makes changes affecting CIs, wherein different types of changes require different levels of confidence in the integrity of data in the CMDB. In response to a proposed change, weights assigned to system CIs affected by the change are used to compute a confidence level regarding accuracy of CMDB data pertinent to the change. The weight for a given CI is derived from the most recent synchronization thereof, and the numbers of reads, writes, and relationships the given CI has with other CIs. The confidence level is then used by the Change Manager in deciding whether or not to make the change. The proposed change is then allowed only if the confidence level is no less than a pre-specified minimum value. | 09-29-2011 |
| 20110252403 | COMPONENT RELINKING IN MIGRATIONS - Component relinking in migrations may include discovering one or more dependencies in one or more components; planning one or more new locations where the one or more components are to be placed; determining relinking needs in the one or more components based on the discovering and the planning; and applying the relinking needs. | 10-13-2011 |
| 20110265064 | DETECTING, USING, AND SHARING IT DESIGN PATTERNS AND ANTI-PATTERNS - Various embodiments described and illustrated herein include at least one of systems, methods, and software to identify, use, or share patterns and anti-patterns. Embodiments that include pattern and anti-pattern identification operate to identify candidate patterns and anti-patterns within a deployed system and to confirm or receive confirmation that the identified candidates are indeed patterns or anti-patterns. Embodiments that use patterns and anti-patterns operate to consume the identified patterns and anti-patterns to improve system performance. The embodiments that share patterns and anti-patterns include mechanisms whereby patterns and anti-patterns can be sent to and received from other systems. | 10-27-2011 |
| 20110276941 | CONNECTING METHOD AND APPARATUS - A connecting apparatus determines whether an external service is compatible with an interface through which a component connected with another component or another external service uses a service of the other component or the other external service, and if it is determined that the external service is compatible with the interface through which the component uses the other component or the other external service, modifies the connection so that the component connected with the other component or the other external service is connected with the external service. The connecting apparatus then executes the component connected with the external service. | 11-10-2011 |
| 20110276942 | Discovering Multi-Component Software Products - A solution ( | 11-10-2011 |
| 20110283259 | METHOD AND SYSTEM FOR CREATING A PLATFORM APPLICATION WITH MULTIPLE APPLETS - A method and system for creating a telephony application with multiple applets, wherein the applets operate through a telephony platform, including the steps instantiating at least a first applet in an application configuration; adding an applet reference of a second applet in an outlet of the first applet; mapping a telephony endpoint to the first applet in an application configuration; and deploying the application on the telephony platform wherein an incoming communication to the telephony endpoint is routed to the first applet. | 11-17-2011 |
| 20110289478 | ORGANIZATION OF APPLICATION STATE AND CONFIGURATION SETTINGS - The operating system manages software entities by creating a construct called a context that organizes and manages software-related state and configuration settings of applications. A context may comprise an installation service, a configuration service and an activation service. Contexts can be linked or arranged hierarchically to form parent-child relationships. Hierarchies may be used to affect accessibility of software items, to satisfy dependencies, to control the visibility/invisibility of software items, to provide access to configuration settings and to override software availability, dependencies and configuration settings. An override may be applied to set policy when more than one context has a configuration setting, dependency or access to a software entity. | 11-24-2011 |
| 20110296379 | AUTOMATED METHOD FOR DECOUPLING AVIONICS APPLICATION SOFTWARE IN AN IMA SYSTEM - A method to decouple software in an integrated modular system that employs message-based data exchange is provided. The method includes generating at least one configuration table for use by core software in at least one module in the integrated modular system. The at least one module hosts at least one of a consuming application. The method also includes gathering parameter data from producer messages at the core software in the at least one module based on the generated configuration table, and creating target messages at the core software based on the gathered parameter data. The target messages have a format specific to the consuming application. | 12-01-2011 |
| 20120036496 | PLUG-IN BASED HIGH AVAILABILITY APPLICATION MANAGEMENT FRAMEWORK (AMF) - A high availability method enabling addition and removal of an application plug-in comprises launching the high availability system using a processor, said high availability system having an application framework (AMF), requesting data obtainable by the application plug-in from the application framework, and when the application plug-in does not exist in the application framework, registering the application plug-in in the application framework. AMF can comprise a list of additional application plug-ins. The list can comprises a unique id, a name, and a path to dynamic load libraries for each application plug-in. AMF can add the application plug-in by adding the application plug-in dynamic load library files to the installation folder and adding application plug-in information to the configuration file. AMF can remove the application plug-in by deleting the application plug-in dynamic load library files from the installation folder and deleting the application plug-in information from the configuration file. | 02-09-2012 |
| 20120079455 | DIRECT SECONDARY DEVICE INTERFACE BY A HOST - A device has a controller and a function module configured to be in communication with the controller as a result of the controller receiving a pass-through vendor specific command. In some embodiments, the controller is configured to receive the pass-through vendor specific command from an application software module of a host through an interface that is configured in accordance with a standard that does not allow communication to occur between the controller and the function module. | 03-29-2012 |
| 20120084751 | Automated Call Center Software Build Generator - A call center (CC) generator includes generator software (GSW) executing on a computerized appliance from a machine-readable physical medium, an input interface for receiving a CC configuration, access to a data repository storing CC software components, a function relating configuration parameters to individual ones of the stored CC software components, and an output interface for delivering a CC SW suite. The CC generator, executing the GSW, considers the CC configuration, applies the relating function, selects CC software components to copy from the data repository, and builds the CC SW suite for output. | 04-05-2012 |
| 20120084752 | IMAGE ASSET LIFECYCLE MANAGEMENT IN A COMPUTING ENVIRONMENT - Lifecycles of virtual image assets are managed as follows. A set of assets including a set virtual image assets and a set of software bundle assets are analyzed. At least a portion of relationship data between one or more of the virtual image assets and one or more of the software bundle assets is determined. The at least a portion of relationship data is stored in a memory. At least one of one or more virtual image assets and one or more software bundle assets are determined to be associated with a set of changes. At least one virtual image asset that is related to the one or more virtual image assets and/or one or more software bundle assets associated with the set of changes is identified. The at least one virtual image asset that has been identified is updated based on the set of changes. | 04-05-2012 |
| 20120096435 | CAPABILITY-BASED APPLICATION RECOMMENDATION - Capabilities associated with a capability-based security model are utilized as a basis for discriminating between software applications. More specifically, software applications can be identified as a function of capabilities. A comparison can be made between software application capabilities and capabilities of interest to identify matches. Subsequently, users can be notified of any matching software applications. | 04-19-2012 |
| 20120102457 | Infrastructure for the Automation of the Assembly of Schema Maintenance Scripts - A method and apparatus to build a migration package. According to one embodiment of the invention, a plurality of programming elements are developed and stored in a configuration repository. The configuration repository also includes metadata used to describe each of the programming elements. Selected programming elements are placed in a set of one or more migration scripts to be stored in the migration package. The set of migration scripts may include a master configuration file and a driver file. | 04-26-2012 |
| 20120124553 | STATUS MANAGEMENT FOR PHASED IMPLEMENTATION OF CONFIGURATION CHANGES - The present disclosure involves systems, software, and computer implemented methods for providing status management for phased implementation of configuration changes. One process includes operations for receiving a selection for a modular software solution and identifying a partial implementation of the modular software solution comprising a subset of the plurality of model entities included in the modular software solution. After the model entities in the subset are activated, a particular model entity is identified to add to the partial implementation. A temporary phase-in state is assigned to the particular model entity, the temporary phase-in state providing an indication to at least one configuration service to perform at least one pre-activation task for the particular model entity. The particular model entity is activated after the pre-activation task is completed. | 05-17-2012 |
| 20120124554 | SERVICE-ORIENTED APPLICATION SYSTEM AND COMMUNICATING METHOD, CREATOR AND CREATING METHOD THEREOF - A service-oriented application system including one or more application objects, each application object includes: a plane structure data unit dedicated to storing data of a special type; a relation storage unit for storing the relations between data in said data unit and data in data units of other application objects; and an application code module for operating the data in the data unit and information in the relation storage unit, and for operating the plane structure data unit and the relation storage unit in response to network service requests. A communication method for the service-oriented application system, a creator and method for creating the service-oriented application system are also provided. The solution can quickly establish and modify the service-oriented application system with no information isolated island exists in the application system, and allows users to share their service data with their providers, customers and collaborators. | 05-17-2012 |
| 20120144369 | TRACKING OWNERSHIP OF MEMORY IN A DATA PROCESSING SYSTEM THROUGH USE OF A MEMORY MONITOR - Ownership of a memory unit in a data processing system is tracked by assigning an identifier to each software component in the data processing system that can acquire ownership of the memory unit. An ownership variable is updated with the identifier of the software component that acquires ownership of the memory unit whenever the memory unit is acquired. | 06-07-2012 |
| 20120151442 | NETWORKED PROGRAM DEPENDENCY COMPATIBILITY ANALYSIS - A web application may be developed in an environment which has different components than a target environment, so determining component dependencies and identifying which dependencies are met in a given environment can be helpful when deploying the application. Toward that end, test code makes a request that test file(s) be sent from a protected location in the target environment, such as from a randomly-named folder or from another location that is not directly browsable by a user. Received test file(s) and network protocol headers are parsed, and component dependency metadata such as component names and version numbers are extracted. Based on the extracted metadata, information is determined about the target environment's installed component(s). By comparing component dependency(ies) of the program with the identified installed component(s) of the target environment, compatibility of the target environment can then be reported. | 06-14-2012 |
| 20120151443 | GLOBALLY SOUND AND CONSISTENT CONFIGURATION MANAGEMENT FOR DISTRIBUTED DATACENTER COMPONENTS - Datacenter configuration needs to be managed. A configuration engine (CE) manages configuration data of clusters and/or datacenters. The CE allows users to check out, edit, and check in configuration components. Versioned interfaces are placed between configuration components through data contracts. The CE supports the expression of constraints that ensure global consistency across configuration components and versions, isolates changes in the datacenter from structural changes in configuration components, and enables partial configuration branching to allow for active snapshots that enable configuration rollback. The CE ensures that types are consistent and constraints are satisfied at check-in time to eliminate unsound or inconsistent configuration in the first place. When the active configuration in the datacenter changes, multiple versions of configuration may be simultaneously deployed for a window of time. The managed set of configuration is permitted to have multiple active versions during these transitional windows to reflect the reality in the datacenter. | 06-14-2012 |
| 20120159438 | Standardized Configuration Checklists For Software Development - Implementations of the present disclosure include methods for generating a configuration checklist template. In some implementations, methods include retrieving one or more source code files, each of the one or more source code files corresponding to a software product, scanning the one or more source code files to generate one or more configuration check building blocks, receiving first user input, processing the one or more configuration check building blocks and the first user input to generate one or more check definitions, receiving second user input, processing the one or more check definitions and the second user input to generate the configuration checklist template, electronically storing the configuration checklist template, and transmitting the configuration checklist template to one or more computing devices associated with a customer entity over a network. | 06-21-2012 |
| 20120159439 | USING APPROPRIATE LEVEL OF CODE TO BE EXECUTED IN RUNTIME ENVIRONMENT USING METADATA DESCRIBING VERSIONS OF RESOURCES BEING USED BY CODE - A method for using an appropriate level of code to be executed in a runtime environment. Code in a non-Java format is translated into a Java source file. During the translation process, metadata is generated from a configuration file where the metadata includes version information of the resources (e.g., JSTL) being used by the code written in the non-Java format. A determination is made as to whether to recompile the non-Java code based on software components, referred herein as “listener components,” determining whether the versions of the resources being used by the non-Java code performs acceptably well in the runtime environment. If a listener component determines that a version of a resource being used is not acceptable, then the non-Java code is recompiled with a newer version of the resource. In this manner, an appropriate level of code is executed by the runtime environment. | 06-21-2012 |
| 20120159440 | SOFTWARE DEVELOPMENT - A method for developing software in which the software comprises a plurality of programs. A change to a program is received. A data structure checking procedure may then be invoked. The changed program is parsed for a reference to a data structure. Other instances of the data structure are located in other programs within the software. The referenced data structure is compared to the located other instances of the data structure. A predefined action (such as notifying a programmer or correcting the inconsistencies) is performed in response to any detected differences between the referenced data structure and the located other instances of the data structure. These steps are repeated for all data structures within the changed program. | 06-21-2012 |
| 20120167044 | VIRTUALIZING EMBEDDED DEVICES - A device virtualization system is described herein that separates common computer processing tasks of an embedded device from the application-specific peripherals of the embedded device to allow at least some functions of the device to be offloaded to servers or other computing devices. The device virtualization system greatly simplifies management, configuration, and control of virtual embedded devices. Because much of the software of the device runs on the virtualization server, information technology (IT) personnel can be assigned to manage the virtualization server and to apply any updates and diagnose any problems that occur. Moreover, a single server or group of servers can be used to provide virtualization services for a wide variety of virtualized embedded devices for a wide variety of users. Thus, the system enhances the usefulness of embedded devices and allows a longer lifetime and wider variety of uses than embedded devices today. | 06-28-2012 |
| 20120167045 | APPARATUS AND METHOD FOR EVALUATING AUTOSAR META FILE-BASED BASIC SOFTWARE PROPERTIES - Disclosed herein is an apparatus for evaluating Automobile Open System Architecture (AUTOSAR) meta file-based basic software properties. The apparatus includes a meta file generation unit, a basic software configuration unit, and a basic software property evaluation unit. The meta file generation unit generates the meta file properties of an AUTOSAR meta file. The basic software configuration unit sets the basic software properties of a basic software configuration file. The basic software property evaluation unit evaluates basic software properties using the meta file properties in order to determine whether the basic software properties were set in conformity with an AUTOSAR standard. | 06-28-2012 |
| 20120167046 | ASSIGNING RUNTIME ARTIFACTS TO SOFTWARE COMPONENTS - A method for assigning runtime artifacts to software components. Source code and metadata are extracted from a library, where the metadata includes a component membership for the source code. A compile unit is formed from the extracted source code and metadata. Runtime artifacts are produced from the compile unit or an element derived from the compile unit. Each runtime artifact is interrogated to determine the defined component for each runtime artifact. The determined component is recorded. | 06-28-2012 |
| 20120174065 | SOFTWARE CHANGE MANAGEMENT EXTENSION FOR UNIFORMLY HANDLING ARTIFACTS WITH RELAXED CONTRAINTS - 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. | 07-05-2012 |
| 20120180026 | SYSTEM AND METHOD FOR UPDATING INITIALIZATION PARAMETERS FOR APPLICATION SOFTWARE FROM WITHIN A SOFTWARE DEVELOPMENT ENVIRONMENT - A computer implemented method for updating initialization parameters for application software from within a software development environment. The method involves changing a value of at least one initialization parameter contained in a configuration file of a developer computer system. The method also involves starting application software deployed on an application server in response to the value change. Thereafter, the configuration file including the changed value of the initialization parameter is communicated from the developer computer system to the application server. Once the configuration file is received at the application server, the application software is initialized using the configuration file. | 07-12-2012 |
| 20120185827 | CUSTOM CODE LIFECYCLE MANAGEMENT - A method is provided to manage program code that runs in a computer system comprising: producing a management information structure that identifies a managed system within the computer system; producing a master object definition information structure that provides a mapping between master objects and corresponding managed code objects that run in the computer system; and requesting extraction of information from the managed system identified by the master information structure that relates to managed code objects that the object definition information structure maps to master objects. | 07-19-2012 |
| 20120192152 | Application-Based Specialization For Computing Nodes Within A Distributed Processing System - A distributed processing system is described that employs “application-based” specialization. In particular, the distributed processing system is constructed as a collection of computing nodes in which each computing node performs a particular processing role within the operation of the overall distributed processing system. Each of the computing nodes includes an operating system, such as the Linux operating system, and includes a plug-in software module to provide a distributed memory operating system that employs the role-based computing techniques. An administration node maintains a database that defines a plurality of application roles. Each role is associated with a software application, and specifies a set of software components necessary for execution of the software application. The administration node deploys the software components to the application nodes in accordance with the application roles associates with each of the application nodes. | 07-26-2012 |
| 20120204149 | DISCOVERY-BASED MIGRATION CORRECTNESS TESTING - Software components migrated from a source server to a target server may be compared before and after a migration. In one aspect, discovery tools may be used to discover the source server's configurations before the migration. Similarly, discovery tools may be used to discover the target server's configurations after the migration. A migration design or plan may be applied to the discovered source server configurations to generate a desired target server configuration. The desired target server configurations may be compared with the discovered target server configurations. Deviations or differences between the discovered target server configurations and the desired target server configurations may be determined. A database of common or typical changes, which might not be specified in the migration plan, may be used to identify the common changes that occur as part of a migration process, from the deviations. | 08-09-2012 |
| 20120204150 | SYSTEM AND METHOD FOR USAGE PATTERN ANALYSIS AND SIMULATION - Systems and methods are provided for analyzing usage patterns. In certain embodiments, a system includes a scenario observer, a scenario associator, and a scenario analyzer. The scenario observer is configured to acquire event data relating to a plurality of events on a system having software and hardware, wherein the plurality of events comprises user input. The scenario associator is configured to associate the event data with a plurality of scenarios. The scenario analyzer configured to analyze the plurality of scenarios to identify usage patterns of the system. | 08-09-2012 |
| 20120204151 | METHOD AND SYSTEM FOR SYNCHRONIZING CHANGES BETWEEN PRODUCT DEVELOPMENT CODE AND RELATED DOCUMENTATION - A method and system for synchronizing source code files and related documentation during software development of a software product including a plurality of files, each file being assigned to a owner, including the steps of: an Event Manager module detecting a change made by a programmer in a file of the plurality of files and saving the status of the file before the change; an Event Handler module identifying the owner of the file containing the detected change; the Event Handler module notifying the owner of the detected change; prompting the owner in approving or rejecting the change; responsive to the owner input, synchronizing the plurality of files or deleting the detected change rolling back to the saved status. | 08-09-2012 |
| 20120210304 | PROGRAM RECONFIGURATION SYSTEM AND PROGRAM RECONFIGURATION METHOD - Customized programs of dealing with a tenant individual condition is reconfigured into a single program, without degradation of performance. Specifically, a program reconfiguration system which reconfigures the programs of dealing with the tenant individual condition into the single program, includes: a program development section configured to correct a part of a program sequence configuring a base program to create a customized program; a customization management table control section configured to create and update a customization management table; a program sequence attribute registering section configured to register the program sequences configuring the base program; a customization record registering section configured to register correction performed in case of the creation of the customized program every program sequence; a tenant attribute registering section configured to register attribute data of a tenant on the customization management table; and a program sequence calculating section configured to determine a use location of a multiple deployment program sequence. | 08-16-2012 |
| 20120227032 | METHOD, APPARATUS, AND SYSTEM FOR INVOKING WIDGET - A method includes: parsing a widget package that is to be run in a terminal to obtain component information in the widget package; obtaining registration information of a component in the widget package according to the component information; when the obtaining of the registration information fails, downloading a component according to component download request information sent by the terminal and updating the registration information; and invoking the downloaded component according to the updated registration information, so that a widget logic component may be updated separately, and a function of a widget terminal is implemented flexibly and easily. | 09-06-2012 |
| 20120240103 | METHOD AND SYSTEM FOR IMPLEMENTING SELF-CONFIGURABLE SOFTWARE COMPONENTS - A system and method for implementing automatic self-configuration of a software component for servicing consumer requests is provided. The method includes receiving a consumer request for a software service by the software component. The method further includes creating one or more rules for defining one or more significant parameters of the software component based on requirements of the consumer request. Thereafter, current values of the one or more parameters are determined by a software agent implemented by the software component. Current values of the one or more parameters are then compared with values defined as per the created rules for checking whether requirements for servicing the consumer request are conformed. If it is determined that requirements for servicing the consumer request are not conformed, at least one parameter of the one or more parameters is configured. Following configuration of the parameter, the consumer request is executed. | 09-20-2012 |
| 20120246616 | 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 |
| 20120254835 | STRUCTURAL SEARCH OF SOURCE CODE - Techniques and tools are described for searching source code. For example, source code can be indexed, a code structure query can be received, index records that conform to the code structure query can be identified, and code structure query results that correspond to the identified index records conforming to the code structure query can be sent. Also for example, a code structure query can be sent, a list of code structure query results corresponding to index records that conform to the code structure query can be received, at least one of the code structure query results can be selected, based on the selection, a formatted source-code file and a code hierarchy can be received, a code annotation associated with the formatted source-code file can be sent, and an annotation result corresponding to the formatted source-code file can be received. | 10-04-2012 |
| 20120254836 | Apparatus, System, and Method for Managing Industrial Software Configurations - An apparatus, system, and computer-implemented method of managing a software program. The computer comprises a processor, a memory, and an input/output interface for receiving and transmitting information to and from the processor, the computer providing a development environment for developing a set of instructions executable by a system. The processor receives a first program containing information in machine-readable form. The information represents a first set of instructions executable by the system. A configuration is created for the system based on the received information. The processor generates a second program containing a second set of instructions executable by the system based on the configuration. The second set of instructions corresponds to at least one algorithm assembled in a nested hierarchy. | 10-04-2012 |
| 20120284692 | DETERMINING RELEASE DIFFERENCES - A method, computer program product, and system for determining release differences is described. A method may comprise determining a first difference, the first difference corresponding to one or more activities that were at least one of: added to a main branch between a first release branch and a second release branch, and removed from the main branch between the first release branch and the second release branch. The method may further comprise determining a second difference, the second difference corresponding to one or more activities that were at least one of: added to the first release branch, and removed from the first release branch. The method may additionally comprise determining a third difference, the third difference corresponding to one or more activities that were at least one of: added to the second release branch, and removed from the second release branch. A delta activity set may be determined. | 11-08-2012 |
| 20120284693 | DETERMINING RELEASE DIFFERENCES - A method, computer program product, and system for determining release differences is described. A method may comprise determining a first difference, the first difference corresponding to one or more activities that were at least one of: added to a main branch between a first release branch and a second release branch, and removed from the main branch between the first release branch and the second release branch. The method may further comprise determining a second difference, the second difference corresponding to one or more activities that were at least one of: added to the first release branch, and removed from the first release branch. The method may additionally comprise determining a third difference, the third difference corresponding to one or more activities that were at least one of: added to the second release branch, and removed from the second release branch. A delta activity set may be determined. | 11-08-2012 |
| 20130007709 | SOFTWARE CONFIGURATION MANAGEMENT - Dependency information corresponding to an artifact can be generated. In response to the generation of the dependency information, information version information is generated for the dependency corresponding to that of the artifact. In response to the update of the artifact, the dependency information corresponding to the artifact is updated. In response to the update of the dependency information, new version information is assigned to the updated dependency information, such that the new version information corresponds to the version information of the updated artifact. | 01-03-2013 |
| 20130014082 | METHOD OF CONFIGURING BUSINESS LOGIC SUPPORTING MULTI-TENANCY - The present invention relates to a method of configuring business logic supporting multi-tenancy. The method includes the steps of an application execution platform storing business logic, received from a service development tool, in a metadata storage unit as a common business logic, the application execution platform determining whether a modified business logic has been received from the service configuration tool of a tenant and if the modified business logic is determined to have been received, the application execution platform storing the modified business logic in the metadata storage unit as business logic dedicated to the tenant. In accordance with the present invention, since each of tenants who have subscribed to service can configure business logic for application service through the service configuration tool, each tenant may modify and used business logic in a desired form. | 01-10-2013 |
| 20130047136 | Automatic Selection of Lowest Configuration Feature Level by Functionality Exploited - Methods and systems of generating product configuration files may involve receiving an identification of a set of features for a software product via a file editor interface. The lowest version of the software product that supports the set of features may be determined, wherein a configuration file can be generated based on the lowest version. In one example, the configuration file identifies the set of features and includes the lowest version as an attribute of the configuration file. | 02-21-2013 |
| 20130047137 | COMPUTER SYSTEM, PROGRAM, AND METHOD FOR COMPARING COMPONENT WEIGHTS BETWEEN BUILDS - A computer system, program, or method may provide for quantifying changes in an individual component among a plurality of components in a software development environment where the components are incorporated in a build. This may include calculating a baseline weight of the individual component prior to a change; effecting, in the software development environment, the change to the individual component; calculating a modified weight of the individual component after the change; determining a threshold for a difference between the baseline weight and the modified weight of the individual component; calculating the difference between the baseline weight and the modified weight of the individual component; and providing on the software development computer a notification if the difference exceeds the threshold. The weights of the individual component may use data such as a count of other components required by the individual component, an install size, a runtime memory usage, a depth of a dependency tree, a component license type, a component category for memory location, a component code type, and/or other types of data. | 02-21-2013 |
| 20130047138 | SYSTEMS AND METHODS FOR BUILDING AND DISTRIBUTING SOFTWARE PACKAGES - Embodiments relate to systems and methods for building and distributing software packages. A package manager generation tool can interface with a set of stages of a development environment to receive source code configured for a software package build. The package manager generation tool can further receive a configuration file from a web user interface, wherein the configuration file can comprise a set of commands that, when executed, can build a software package from the source code. A distribution schedule can indicate one or more distribution systems to which to distribute the software package. The package manager generation tool can distribute the software packages to the distribution systems specified by the distribution schedule. | 02-21-2013 |
| 20130047139 | Automatic Selection of Lowest Configuration Feature Level by Functionality Exploited - Methods and systems of generating product configuration files may involve receiving an identification of a set of features for a software product via a file editor interface. The lowest version of the software product that supports the set of features may be determined, wherein a configuration file can be generated based on the lowest version. In one example, the configuration file identifies the set of features and includes the lowest version as an attribute of the configuration file. | 02-21-2013 |
| 20130061208 | TRANSFORMATIONAL CONTEXT-AWARE DATA SOURCE MANAGEMENT - Porting between local, cluster, and cloud execution is aided by using the same source code for multiple data sources. A data source identifier recited in source code maps to data sources at different execution targets. Executable codes tailored to successive targets are produced using a resolution API without changing the developer's source code. An editable data source mapping is per-project, maintained in a file or project property, and placed in a distributable software package with executable code. Burdens on developers to determine execution targets in their source code and explicitly handle different execution locations in the source code are reduced. Source code can be freed of absolute path data source identifiers or code for detecting execution location. Source-to-source translation injects calls to create a folder, file, or cloud container. Data source resolution can be based on a relative path rooted at the data source identifier. | 03-07-2013 |
| 20130067435 | METHOD AND APPARATUS FOR PROGRAMMING ASSISTANCE - A programming assistance technical solution for a framework-based application program. The application program contains program files and configuration files, including: processing configuration files of an application program history base into a configuration file classification base according to types of frameworks; constructing a Closed Frequent Subtree Set according to the configuration file classification base and determining a support of the Closed Frequent Subtree; and providing the Closed Frequent Subtree Set and the support for programming assistance. The technical solution of the present invention can be employed to assist in programming of a framework-based application program. | 03-14-2013 |
| 20130080997 | System and Method for Tracking and Notifying Related Software, Modules, and Configuration Files During Software Development and Maintenance - 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. | 03-28-2013 |
| 20130091489 | COMPUTING DEVICE, STORAGE MEDIUM AND METHOD FOR PROCESSING SOURCE FILES USING THE COMPUTING DEVICE - In a method for processing source files using a computing device, a source file and a configuration file is downloaded from a server. The method reads each line of instructions from the configuration file. A replacement string is generated according to a predetermined prefix name from the configuration file and information of an operating system of the computing device. A name of the source file is obtained from the configuration file, and a name of an execution file corresponding to the source file is obtained according to the replacement string. The method notifies a compiling unit reading and compiling the source file according to the name of the source file, and generates the execution file with the name of the execution file. | 04-11-2013 |
| 20130097584 | MAPPING SOFTWARE MODULES TO SOURCE CODE - A class map is created based on source code for a subject program that includes program modules. The class map maps the program modules to object-oriented programming classes referenced by the source code. A log map is created based on the class map and logging-mechanism configuration files. The logging-mechanism configuration files map the classes to log files. The log map maps the program modules to log files. | 04-18-2013 |
| 20130111439 | SOFTWARE DEVELOPMENT PLATFORM WITH ENHANCED FEATURE CONTROL AND REUSABILITY | 05-02-2013 |
| 20130111440 | Methods, Apparatuses, and Computer-Readable Media for Computing Checksums for Effective Caching in Continuous Distributed Builds | 05-02-2013 |
| 20130111441 | PARALLEL DEVELOPMENT OF A SOFTWARE SYSTEM | 05-02-2013 |
| 20130111442 | PARALLEL DEVELOPMENT OF A SOFTWARE SYSTEM | 05-02-2013 |
| 20130139126 | MOBILE APPLICATION CONFIGURATION - A user device receives a mobile application that defines multiple environments associated with the mobile application and launches the mobile application. After the launching the mobile application, the user device retrieves an environment selector value for the mobile application and initializes the mobile application with configuration data for a particular environment of the multiple environments. The particular environment is selected from the multiple environments based on the environment selector value. | 05-30-2013 |
| 20130145349 | Metadata Merging In Agent Configuration Files - A technique for updating agent software which controls an agent, including how the agent adds instrumentation to an application and how the agent process data from the instrumentation. A current configuration file and an updated configuration file are evaluated in view of rules, to create a merged configuration file. The files include metadata entries. The rules can include: delete a current configuration file, not merge a current configuration file with an updated configuration file, overwrite a current configuration file with an updated configuration file, delete a metadata entry, prefer an entry in the configuration file over a corresponding entry in the updated configuration file, and prefer an entry in the updated configuration file over the corresponding entry in the configuration file. Customized entries in the current configuration file can be maintained if appropriate. Entries which are not maintained are kept in the merged configuration file as inline comments for documentation. | 06-06-2013 |
| 20130159973 | ACTIVATION LOGIC GENERATION FOR A SOFTWARE APPLIANCE - Embodiments relate to generating an activation logic component for a software appliance. An aspect includes analyzing configuration settings of a software component, the software component being installed in a first system environment. Another aspect includes generating an image-based installation version of the software component for a second system environment, the second system environment being distinct from the first system environment. Yet another aspect includes generating an activation logic component, such that the image-based installation version of the software component and the activation logic component are generated by an activation logic generator. | 06-20-2013 |
| 20130167117 | Synchronization of Prospect Information Between Software Providers and Resale Partners - The present disclosure describes methods, systems, and computer program products for synchronizing opportunity information in a software-related sales environment. One method includes identifying, at a software configuration application, a first set of opportunity information from a software reseller and a second set of opportunity information from a software provider, where the first and second set of opportunity information associated with a prospective software customer. The method further includes integrating the first and second set of opportunity information into a combined set of opportunity information within the software configuration application and identifying at least one modification to the combined set of opportunity information. The method then provides the at least one identified modification to the combined set of opportunity information to the software reseller and the software provider to synchronize the first and second sets of opportunity information. | 06-27-2013 |
| 20130167118 | MANAGING SYMBOLIC LINKS IN DOCUMENTATION - A method of managing links can include inserting a universal resource identifier for a software asset within a link resolution file, wherein a symbolic link within a document that is independent of the link resolution file references the link resolution file. The method also can include publishing the document and the link resolution file and, responsive to a selection of the symbolic link within the document, resolving the symbolic link to the universal resource identifier using the link resolution file. | 06-27-2013 |
| 20130167119 | APPARATUS AND METHOD FOR SUPPORTING SOFTWARE DEVELOPMENT FOR VEHICLE - An apparatus and method for supporting development of software for vehicles which may classify functions required from a vehicle-IT development viewpoint as components and use the classified components in order to easily develop vehicle-IT application software such as navigation software or a black box are provided. The apparatus for supporting development of software for vehicles includes a common interface that provides a communication connection with a vehicle application service development device for developing vehicle-IT-related application services, and a common component management unit that manages a common component for configuring functional data of a vehicle used in developing the vehicle-IT-related application services as a component to be reused, and provides the common component to the vehicle application service development device through the common interface in response to a request from the vehicle application service development device. | 06-27-2013 |
| 20130174122 | META-DATA FOR SINGLE DEVELOPMENT TEST ENVIRONMENT - System and method for generating meta-data for a product is disclosed. An artifact repository stores first artifacts for building the product. The artifact repository stores first meta-data for one or more of the artifacts in the repository. A build manager builds second artifacts for the product from source code and one or more of the first artifacts based on information in a project script. The build manager is adapted to combine the first meta-data for each of the one or more of the first artifacts used to build the second artifact to form second meta-data for each of the second artifacts. | 07-04-2013 |
| 20130174123 | SYSTEM AND METHOD FOR APPLICATION CONFIGURATION COMPARISON AND REUSE - A system and method allow a user to extract the set of customizations performed on an application and use these to estimate the time and effort and cost of (a) migrating to a new version of the application and/or (b) consolidating systems. The user can browse the extracted data and select configuration elements for re-use. After downloading the one or more configurations and comparing them, the user selects elements of the configurations for re-use. The first step is to scan one or more application systems and extract the configuration data using a surveyor. The method according to the invention automatically identifies configuration differences. The user then selects configuration elements for re-use. A graphic user interface (GUI) can be provided which allows the user to make these selections by dragging and dropping selected elements to a “To Be” configuration. The selected configurations are then uploaded and installed on an instance of the application. | 07-04-2013 |
| 20130179862 | CONFIGURATION MODELING WITH OBJECTS - A computer-implemented method, computer program product and system for configuration modeling with objects are disclosed. A base configuration of an application is modeled, to generate a configuration model that specifies parameters, types, structures, and boundary conditions of the base configuration of the application. The configuration model is stored in a database repository as a repository object that can be activated with configuration data. One or more extensions to the base configuration is modeled as one or more configuration model extensions. The one or more configuration model extensions are stored as repository objects linked to the repository object representing the configuration model. | 07-11-2013 |
| 20130198716 | CONFIGURATION FILE COMPATIBILITY - Disclosed herein is a technique that compares a first series of bits associated with a configuration file with a second series of bits associated with computer readable instructions so as to determine whether the configuration file is compatible with the instructions | 08-01-2013 |
| 20130198717 | Unified Software Build System - A computer-implemented method for generating one or more build system build files using a unified build system configuration file includes: receiving the unified build system configuration file in a computer system, the unified build system configuration file comprising at least one platform-independent build system configuration; generating, using the computer system, at least one platform-specific build system configuration from the at least one platform-independent build system configuration; selecting at least one template for the unified build system configuration file, the template selected from among templates corresponding to each of multiple platforms; generating the one or more build system build files for at least one of the multiple platforms using the platform-specific build system configuration and the selected template; and providing the generated one or more build system build files in response to the unified build system configuration file. | 08-01-2013 |
| 20130198718 | AUTOMATED CONFIGURATION OF AN APPLICATION IN A COMPUTING PLATFORM - Upon receiving application code and an application descriptor of an application, a platform executing on a computer system identifies a capability to be used by the application based on the application descriptor. The platform determines a component that provides the capability based on a component descriptor of the component. The platform then configures the application and the component for execution on the platform. | 08-01-2013 |
| 20130198719 | AUTOMATED DEPLOYMENT OF AN APPLICATION IN A COMPUTING PLATFORM - A platform executing on a computer system configures an application and components that provide capabilities to the application based on an application descriptor of the application, the application and the components to be run on a plurality of nodes of the platform that are arranged in a cluster. The platform assigns a first set of the components to run on a first node of the plurality of nodes and a second set of on the components to run on a second node of the plurality of nodes. The platform installs the first set of the components on the first node and the second set of the components on the second node. | 08-01-2013 |
| 20130205277 | ENVIRONMENT AND METHOD FOR CROSS-PLATFORM DEVELOPMENT OF SOFTWARE APPLICATIONS - A method may include obtaining content files, where the content files include one or more presentation files, where each presentation file includes respective instructions which, when interpreted at runtime by a separate computing device, are configured to provide at least one of (a) a functionality and (b) a user interface of a software application executing upon the separate computing device. The method may include providing the content files to the separate computing device. After providing the content files, the method may include identifying a change in at least a first presentation file, and providing at least the first presentation file to the separate computing device, where the software application is configured to execute the first presentation file as at least one of (a) the functionality and (b) the user interface of the software application without need for re-installing or re-loading the software application on the separate computing device. | 08-08-2013 |
| 20130205278 | SYSTEMS AND METHODS FOR A MOBILE APPLICATION DEVELOPMENT AND DEPLOYMENT PLATFORM - Systems and methods for developing, customizing, and deploying mobile device applications are provided through a mobile application development and deployment platform. Preferably, these systems and methods are implemented in an Internet based environment that allows non-technical users to build sophisticated, highly-customizable cross-platform mobile applications. The platform allows users to select, input, create, customize, and combine various content, design characteristics, and application components, such as modules, some of which utilize features and functionality associated with various mobile devices and mobile operating systems. In certain embodiments, the platform allows users to compile, and generate a configuration file for, the mobile application that can be distributed to end users for execution on various mobile devices and mobile operating systems. When the mobile application is installed on, or executed by the mobile device, the configuration file may enable the retrieval of various data associated with the mobile application. | 08-08-2013 |
| 20130219360 | Customizing Synchronization of Custom Code among Multiple Programmable Hardware Elements within a System - Customizing a target system. The target system may include a first device with a first programmable hardware element (PHE) and a second device with a second PHE. Synchronization modules may be provided for implementation on the first and second PHEs. The synchronization modules may provide a standard interface for interacting with other code. A user may specify user-created code for the first and second PHEs which utilizes the synchronization modules. The user-created code may interact with the synchronization modules using the standard interface. Accordingly, hardware descriptions may be generated for the first and second PHEs of the target system. Different modules may be used for different interconnects. Additionally, multiple synchronization modules may be used, e.g., dynamically, during operation of the target system. | 08-22-2013 |
| 20130219361 | SYSTEM AND METHOD FOR CONTROLLING THE DEVELOPMENT OF A SOFTWARE APPLICATION - Certain example embodiments relate to techniques for controlling the development of a software application. The system includes an event channel for receiving at least one event that indicates an action performed by one of a plurality of existing development tools used in the development of the software application, a policy-based event engine for evaluating the at least one event and for initiating at least one action of one of the plurality of existing development tools in accordance with at least one policy, and a repository, for storing at least one artifact to define an architecture of the software application. The at least one artifact corresponds to a component of the software application and/or to a dependency between a first component and a second component of the software application. | 08-22-2013 |
| 20130227524 | METHOD AND APPARATUS FOR ANALYZING APPLICATION PROGRAM BY ANALYSIS OF SOURCE CODE - A method and an apparatus for analyzing source codes of an application program having open source codes and analyzing features which are used in the application program are provided. The method includes analyzing the application program according to the source codes in the application program, determining application program configuration information used in the application program, and classifying and outputting the application program configuration information according to the determined application program configuration information. | 08-29-2013 |
| 20130232469 | SYSTEM AND METHOD FOR AUTOMATICALLY RESOLVING DEPENDENCIES OF JAVA ARCHIVE FILES FOR USE WITH MAVEN - A system and method is provided for automatically resolving dependencies of Java Archive (Jar) files, for use with software development tools such as Maven. A Maven coordinate determination logic is used to generate Maven coordinate information for, e.g., an Open Service Gateway Initiative (OSGi)-based Jar file. In accordance with an embodiment, an OSGi class loader is used to automatically determine Maven coordinates and dependency information based on the contents of the Jar, and store the coordinates and dependency information in a generated Project Object Model (POM) file. | 09-05-2013 |
| 20130232470 | LAUNCHING AN APPLICATION STACK ON A CLOUD PLATFORM ENVIRONMENT - An application stack is launched on a cloud platform environment. An application manifest is created for each application in the application stack that is to run in a cloud platform environment. The application manifest includes, for each application, dependency information indicating application relationships and dependencies. The translated application manifests are used to construct the application stack within the cloud platform environment. | 09-05-2013 |
| 20130247005 | SYSTEMS AND METHODS FOR A MOBILE BUSINESS APPLICATION DEVELOPMENT AND DEPLOYMENT PLATFORM - Systems and methods for developing, customizing, and deploying mobile device business applications are provided through a mobile application development and deployment platform. Preferably, these systems and methods are implemented in an Internet based environment that allows non-technical users to build highly-customizable cross-platform mobile applications. The platform allows users to select, input, create, customize, and combine various content, design characteristics, database structure, and application components, such as modules, some of which allow an end user to store and access data in an end user database for business applications. In certain embodiments, the platform allows users to compile and generate a configuration file for the mobile application that can be distributed to end users for execution on various mobile devices and mobile operating systems. When the mobile application is installed on, or executed by the mobile device, the configuration file may enable the retrieval of data associated with the mobile application. | 09-19-2013 |
| 20130263088 | DYNAMIC PLUGIN(S) FOR CLOUD APPLICATION(S) - Techniques are described herein that are capable of dynamically installing plugin(s) for application(s). An agent plugin is caused to run in a deployment of a specified application (e.g., across multiple machines in a cloud environment or “on premises”). The specified application is packaged to include the agent plugin. The agent plugin is used to install designated plugin(s) dynamically based on configuration information regarding the specified application. The configuration information indicates that the designated plugin(s) are to be installed in response to the specified application being deployed. | 10-03-2013 |
| 20130268915 | DISTRIBUTED PARALLEL BUILD SYSTEM - 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. | 10-10-2013 |
| 20130283234 | System And Method For Automated Software Application Developement - A computer-implemented method for identifying a new software application to be developed. A computer database is searched for matching keywords that correspond to any of a group of selected keywords, indicative of the new application. The database contains descriptive keywords which are indicative of a set of existing applications. If no matching keywords are found in the database, then a description of the new application is requested from the potential user; the description of the new application is received from the potential user; and the description of the new application is used as a basis for developing the new application. | 10-24-2013 |
| 20130290929 | METHOD OF MANAGING SCRIPT, SERVER PERFORMING THE SAME AND STORAGE MEDIA STORING THE SAME - The present invention relates to a script management technology. Disclosed are approaches for managing scripts carried out in a script management server, which is connected to a user terminal and which manages script codes. Approaches comprise preparing a plurality of databases including a meta database and a plurality of script databases without necessarily separating physically the two types of databases; designating an active script database by providing the plurality of the original script lists to the user terminal; and storing identifiers of the user terminal and the designated active script database in the meta database, where the plurality of script databases are classified according to script version and each of them manages the original script code and user-specific script code, and the meta database manages a plurality of the original script lists related to the plurality of script databases and a list of user-specific scripts. | 10-31-2013 |
| 20130290930 | RESOURCE DEPLOYMENT BASED ON CONDITIONS - Architecture that facilitates the package partitioning of application resources based on conditions, and the package applicability based on the conditions. An index is created for a unified lookup of the available resources. At build time of an application, the resources are indexed and determined to be applicable based on the conditions. The condition under which the resource is applicable is then used to automatically partition the resource into an appropriate package. Each resource package then becomes applicable under the conditions in which the resources within it are applicable, and is deployed to the user if the user merits the conditions (e.g., an English user will receive an English package of English strings, but not a French package). Before the application is run, the references to the resources are merged and can be used to do appropriate lookup of what resources are available. | 10-31-2013 |
| 20130298109 | INSTRUMENTATION OF SOFTWARE APPLICATIONS FOR CONFIGURATION THEREOF - A solution is proposed for instrumenting a software application for configuration thereof. A corresponding method includes scanning a source code of the software application for detecting an indication of a set of configuration parameters each one being identified by a pre-defined non-executable statement, creating a set of instances of a pre-defined configuration object each one mapping a corresponding one of the configuration parameters, the configuration object being designed to manage the corresponding configuration parameter, and creating a set of configuration interfaces for editing the configuration parameters, the configuration interfaces being operable to interact with each instance of the configuration object to get and set the corresponding configuration parameter. | 11-07-2013 |
| 20130305221 | SERVICE CONTROLLER FOR AN INTEGRATED SERVICE FRAMEWORK - Embodiments of the invention provide for methods, systems and computer program products for an integrated service framework with a suite of products that provide a development environment and common framework for programming within an operating system. The integrated service framework provides a service controller that allows a programmer or an administrator to control, monitor, query, troubleshoot, and resolve any issues that occur with the services. The service controller provides service interfaces that are completely configurable without the need for programing code to display the individual service interfaces. The service controller provides the service interfaces using the text from a configuration file populated by a user. The user can utilize the service interfaces provided by the service controller to send commands to services to start, stop, pause, and resume the services, monitor information about the services, and query the services to determine if the services are working properly. | 11-14-2013 |
| 20130311972 | Automated tagging and tracking of defect codes based on customer problem management record - A routine for tagging and tracking source code may be implemented in a software development environment. The routine begins upon the identification of a defect in a software product or system. Once the defect has been identified and rectified, a search of other source code (typically located in a source code management system that supports version control) is specified. Using the search specification, the system automatically identifies the code snippet to be searched and begins searching the identified codebase for duplicates. A ticket or service record is then created for every duplicate/similar code snippet found during the search. The ticket/record enables software defect tracking to be carried out on the newly-located instances of the code. The system also automatically manages the code snippets identified by the duplicate detection. | 11-21-2013 |
| 20130318497 | INFRASTRUCTURE FOR THE AUTOMATION OF THE ASSEMBLY OF SCHEMA MAINTENANCE SCRIPTS - A method and apparatus to build a migration package. According to one embodiment of the invention, a plurality of programming elements are developed and stored in a configuration repository. The configuration repository also includes metadata used to describe each of the programming elements. Selected programming elements are placed in a set of one or more migration scripts to be stored in the migration package. The set of migration scripts may include a master configuration file and a driver file. | 11-28-2013 |
| 20130326478 | 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 |
| 20130326479 | SYSTEM AND METHOD FOR TRACKING COMPLIANCE INFORMATION FOR A BUILD-SYSTEM PRODUCT - Systems and methods for tracking compliance information for a build-system product are described. The compliance information is associated with one or more source code files used to build the build-system product. Tracking information is created for the build-system product including a source code identifier for each source code file that contributes to the build-system product. The tracking information can be utilized to identify the source codes files that contributed to the build-system product and identify the associated compliance information. | 12-05-2013 |
| 20130332899 | System for Developing Custom Data Transformations for System Integration Application Programs - A method includes receiving packaged custom data transform element parameters at an information handling system wherein the information handling system hosts an automated development system platform for creating an integrated business process application. The method also includes registering a custom data transform element described by the custom data transform element parameters with the automated development system platform, and updating the automated development system platform with the custom data transform element. | 12-12-2013 |
| 20130332900 | DESIGNING AND CROSS-CONFIGURING SOFTWARE - Various embodiments create a cross-configuration software module for cross-configuring software entities. In one embodiment, a first set of requirements and at least a second set of requirements are obtained. Each of the first and second set of requirements identify at least one of a set of software entities and a set of hardware components required to be present on at least one system including software entities to be cross-configured. At least one set of operations is obtained. The set of operations includes at least one executable instruction that configures a first software entity with a second software entity. A first configuration definition is generated including at least the first set of requirements and the at least one set of operations. A second configuration definition is generated including at least the second set of requirements. The first and second configuration definitions are stored within a cross-configuration software module. | 12-12-2013 |
| 20130332901 | DESIGNING AND CROSS-CONFIGURING SOFTWARE - Various embodiments create a cross-configuration software module for cross-configuring software entities. In one embodiment, a first set of requirements and at least a second set of requirements are obtained. Each of the first and second set of requirements identify at least one of a set of software entities and a set of hardware components required to be present on at least one system including software entities to be cross-configured. At least one set of operations is obtained. The set of operations includes at least one executable instruction that configures a first software entity with a second software entity. A first configuration definition is generated including at least the first set of requirements and the at least one set of operations. A second configuration definition is generated including at least the second set of requirements. The first and second configuration definitions are stored within a cross-configuration software module. | 12-12-2013 |
| 20130346945 | DEPLOYMENT OF SOFTWARE APPLICATIONS ON A CLOUD COMPUTING PLATFORM - In one aspect, a software application with application artifacts is deployed on a cloud computing platform. The cloud computing platform includes a platform product that can provide functionality that is required by the application. Application metadata is created based on analyzing the application artifacts and describes the application artifacts requirement. An application repository stores the application artifacts and the application metadata. A product description defines an application product for the software application and a product reference to the platform product is defined. The product description and the product reference are published in the application repository to update the application metadata. A composite repository refers to the application product and the platform product. The composite repository is transferred to a platform repository provided by the cloud computing platform. | 12-26-2013 |
| 20140007051 | Configuring Integration Capabilities for System Integration | 01-02-2014 |
| 20140007052 | DYNAMICALLY CONFIGURING AN INTEGRATED DEVELOPMENT ENVIRONMENT | 01-02-2014 |
| 20140007053 | DYNAMICALLY CONFIGURING AN INTEGRATED DEVELOPMENT ENVIRONMENT | 01-02-2014 |
| 20140013302 | LOG CONFIGURATION OF DISTRIBUTED APPLICATIONS - A method of configuring a logging utility includes generating, by a computer system, at least one message based on a model of logs from at least two software components of a multi-component application and sending, by the computer system, the message to at least one of the two software components for configuring a logging utility of the corresponding software component. | 01-09-2014 |
| 20140013303 | SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT FOR DETERMINING WHETHER PARAMETER CONFIGURATIONS MEET PREDETERMINED CRITERIA - A system, method, and computer program product are provided for determining whether parameter configurations meet predetermined criteria. In use, predetermined criteria associated with a software element are identified. Additionally, it is determined whether each of a plurality of different parameter configurations meets the criteria, utilizing a directed acyclic graph (DAG). | 01-09-2014 |
| 20140026118 | SOFTWARE REFACTORING - Locating program code units stored on digital data storage includes defining a software module fragment by assigning a software module fragment label to selected program code units, creating a module fragment list defining a software module, said list comprising a set of said software module fragments, receiving a request to retrieve the program code units of a specified software module from the digital data storage, and converting, using a processor, the module fragment list of the specified module into a list of physical locations for resolving the locations of the corresponding program code units on the digital data storage using said labels. | 01-23-2014 |
| 20140033171 | CUSTOMIZABLE MULTISTATE PODS - Apparatus, systems, and methods may operate to receive a configuration of a configurable software object, the configuration including size and position data for displaying the configurable software object in a display. Further actions include retrieving data for the configurable software object, the data retrieved by a client-side engine associated with the display. The data is displayed in the display using the configurable software object, where the configurable software object is configured using the configuration. Apparatus, systems, and methods may also receive a request for a configurable software object, the configurable software object including size and position data for use within a display. Then, retrieve the configurable software object and transmit the configurable software object to a client, the client adapted to display the configurable software object using the size and position data. Additional apparatus, systems, and methods are disclosed. | 01-30-2014 |
| 20140033172 | CONFIGURATION OF WIDGETS IN A MASHUP ENVIRONMENT - A method, system, and/or computer program product configures widgets in a mashup environment. The mashup environment comprises a first widget having a first configuration. In response to an addition of a second widget to the mashup environment, where the second widget has a second configuration, a determination is made as to whether the first widget is related to the second widget by examining interaction relationship information between the first configuration and the second configuration. The first configuration to the second configuration are compared, and in response to determining that the first widget is related to the second widget and that the first configuration and the second configuration are different, the first configuration and/or the second configuration are updated in order to make them match one another. | 01-30-2014 |
| 20140040862 | Copying Reusable Components from a Remote Source - Methods, systems, and apparatus, including computer program products, for reusing a component. In one aspect, a method includes detecting insertion into a target application of a reusable component associated with a remote source; identifying a library corresponding to the reusable component, wherein the library is maintained at the remote source; loading the library into a storage location accessible to the target application to create a local library; and instantiating the reusable component in the target application in accordance with the local library. Further, limited system privileges can be granted to the reusable component. Additionally, the reusable component can be assigned to a sandbox based on one or more granted system privileges. | 02-06-2014 |
| 20140047414 | Importing Profiles for Configuring Specific System Components Into a Configuration Profile for the System - According to a present invention embodiment, a system imports information from a source profile into a target profile. The system maps one or more entities within the source profile to one or more entities of the target profile pertaining to configuring a system including a plurality of system components. Properties of the one or more entities within the source profile are compared to properties of corresponding mapped entities in the target profile. The values of the properties of the one or more entities within the target profile are set to the property values of the corresponding one or more mapped entities within the source profile in response to the comparison indicating the properties correspond. Embodiments of the present invention further include a method and computer program product for importing information from a source profile into a target profile in substantially the same manner described above. | 02-13-2014 |
| 20140059519 | ENABLING MULTI-TENANCY FOR A COMMERCE SERVER - A method and system for enabling multi-tenancy in a commerce server is provided. The method includes receiving software comprising an operating system, integrated development environment (IDE) software, commerce server middleware software, and database software. A virtual image instance of operating system, the IDE software, and the database software is provisioned to a virtual instance. User IDs for access to the operating system instance are generated. Workspaces are generated and associated with the user IDs. The commerce server middleware software is configured such that the user IDs, hosts, and ports are mapped to commerce server services associated with the commerce server middleware software. The database software is configured such that the virtual image instance is enabled to accept multiple concurrent logins associated with the user IDs. | 02-27-2014 |
| 20140075413 | WORKFLOW-BASED APPLICATION GENERATOR - A workflow-based application generator to generate a workflow application based upon at least one received workflow process. The application generator is to generate, based on the received workflow process, workflow configuration rules that include a list of determined workflow pages based on a required functionality, and configuration routing rules that include an order of the workflow pages and dependency information pertaining to the workflow pages. The workflow-based application generator is to generate a workflow context according to the workflow configuration rules, the configuration routing rules, and the retrieved workflow pages. Based upon the generated workflow context, the workflow-based application generator is to build a workflow application. | 03-13-2014 |
| 20140075414 | SYSTEM AND METHOD FOR RECOMMENDING SOFTWARE ARTIFACTS - A method for recommending at least one artifact to an artifact user is described. The method includes obtaining user characteristic information reflecting preferences, particular to the artifact user, as to a desired artifact. The method also includes obtaining first metadata about each of one or more candidate artifacts, and scoring, as one or more scored artifacts, each of the one or more candidate artifacts by evaluating one or more criteria, not particular to the artifact user, applied to the first metadata. The method further includes scaling, as one or more scaled artifacts, a score of each of the one or more scored artifacts, by evaluating the suitability of each of the one or more scored artifacts in view of the user characteristic information. The method lastly includes recommending to the artifact user at least one artifact from among the one or more scaled artifacts based on its scaled score. | 03-13-2014 |
| 20140089895 | TEST CASE PATTERN MATCHING - Received source code is transformed according to a predefined rule set to create an encoded text string representation of each function of the received source code. Each encoded text string representation of each function of the received source code includes a text string that identifies each parameter type of the respective function of the received source code, and is compared in real time with encoded text string representations of stored source code fragments in a repository. Each stored source code fragment is transformed according to the same predefined rule set into the respective encoded text string representations that each include a text string that identifies each parameter type of a respective function of the respective stored source code fragment. An indication of each portion of the received source code determined to already exist as a stored source code fragment in the repository is outputted in response to the real-time comparison. | 03-27-2014 |
| 20140101637 | SELECTIVE NOTIFICATIONS ACCORDING TO MERGE DISTANCE FOR SOFTWARE VERSION BRANCHES WITHIN A SOFTWARE CONFIGURATION MANAGEMENT SYSTEM - A computer-implemented method of controlling version branching within a software configuration management system (SCMS) can include, responsive to a user initiating a check-out operation of a file within the SCMS, identifying the file and a workspace of the user and searching nodes of the repositories of the SCMS for a successor version of the file. When a successor version of the file is located within a node that is within a predetermined distance of the workspace of the user, a notification that the successor version of the file is within the predetermined distance of the workspace of the user can be output. When a successor version of the file is not located within a node within a predetermined distance of the workspace of the user, the file can be checked-out to the workspace of the user. | 04-10-2014 |
| 20140130013 | Multiprocessor Programming Toolkit for Design Reuse - Techniques for specifying and implementing a software application targeted for execution on a multiprocessor array (MPA). The MPA may include a plurality of processing elements, supporting memory, and a high bandwidth interconnection network (IN), communicatively coupling the plurality of processing elements and supporting memory. In one embodiment, software code may include first program instructions executable to perform a function. In this embodiment, the software code may also include one or more language constructs that are configurable to specify one or more communication ports and one or more parameter inputs. In this embodiment, the one or more communication ports are configurable to specify communication with other software code. In this embodiment, the one or more parameter inputs are configurable to specify a set of hardware resources usable to execute the software code. In this embodiment, the hardware resources include multiple processors and may include multiple supporting memories. | 05-08-2014 |
| 20140137080 | SYSTEM AND METHOD OF OPTIMIZATION FOR MOBILE APPS - A network device provides an agent application to a user device. The network device receives, from the user device, device information that relates to performance of one or more applications residing on the user device. The network device provides, to a device associated with a registered developer account, a portion of the device information that is associated with a particular application. The network device receives, from the device associated with the registered developer account, optimized device configuration settings for the particular application on the user device. The network device stores the optimized configuration settings for the particular application and sends, to the user device, the optimized configuration settings for the particular application. | 05-15-2014 |
| 20140149966 | APPLICATION, BUILD, INTEGRATION, AND RELEASE MANAGEMENT SYSTEM AND METHOD - A system and method of building a platform specific application for a device includes receiving an input from the device and determine a platform type of the device based on the input. Source code, specific to a requested application and the platform type, is requested from a source control repository. The platform specific source code is refactored and is transmitted to a platform specific build engine. A platform specific executable is received from the build engine and is stored in an application store to make the platform specific executable available for downloading to the device. | 05-29-2014 |
| 20140157235 | Evaluating Reliability of a Software Module Using Development Life Cycle - Reliability of one or more software modules is projected according to a current state in a development life cycle of the software modules and any of various additional indicators. Preferably, a data processing support provider separate from the service-providing enterprise maintains historical field support data concerning significant field defect events with respect to various resources, and uses this data for projecting reliability of the resources. Preferably, software module reliability projections are used to support an analysis of risk of degradation of a service specified in a service requirements specification when provided by a configuration of data processing resources specified in a configuration specification. | 06-05-2014 |
| 20140165034 | PROGRAM CODE LIBRARY SELECTION IN AN INTEGRATED DEVELOPMENT ENVIRONMENT - An approach for integrated development environment (IDE)-based program code library selection in a networked computing environment (e.g., a cloud computing environment) is provided. Under this approach, a search results file is received in a library selection IDE from a library searching IDE. It may then be determined whether to perform a micro-benchmarking on the at least one method and the at least one class. Based on the determination, the micro-benchmarking may then be performed on the at least one method and the at least one class. A set of code style similarity scores may then be calculated that indicate a similarity between the at least one method and the at least one class with the methods and classes of a second program code file. An ordered list of the methods and classes of the second program code file may then be provided. | 06-12-2014 |
| 20140165035 | EXPANSION AND REDUCTION OF SOURCE CODE FOR CODE REFACTORING - An automated programming tool can receive program source code and can expand portions of the program source code to make to make identifiers explicit, insert sets of parenthesis and so on. Expansions can be kept track of so that reductions after refactoring can be confined to altered portions of the program source code. | 06-12-2014 |
| 20140165036 | METHODS AND APPARATUS FOR AUTHENTICATION OF CONFIGURATION ITEMS VIA CONFIGURATION ITEM CHANGE ANALYSIS - A method comprises retrieving a change history for each of one or more configuration items for a specified time period, retrieving requests for change identifiers utilized for each of the configuration items in the specified time period, generating an audit report for the configuration items in accordance with the retrieved change history and the retrieve request for change identifiers, determining if each attribute value change in the change history of each of the configuration items is authorized, and recording a marker in the change history through which a given configuration item has authorized changes. Determining if each value change is authorized comprises comparing changes in the retrieved change history to the retrieved request for change identifiers for each of the configuration items to distinguish value changes that occurred without a request for change from value changes that occurred with a request for change. | 06-12-2014 |
| 20140173558 | EFFICIENT EXECUTION OF HUMAN MACHINE INTERFACE APPLICATIONS IN A HETEROGENEOUS MULTIPROCESSOR ENVIRONMENT - An arrangement is proposed for creating and executing human-machine interface (HMI) applications in various heterogeneous computing and communication environments. The arrangement includes an engineering system for designing HMI applications based upon a library of known HMI elements, a runtime system for determining an optimum configuration for executing the designed HMI applications and a knowledge repository that communicates with both the engineering system and the runtime system. The knowledge repository stores information related to various ones of the known HMI elements, as well as information created by application developers and information generated during execution of an HMI application by the runtime system. Thus, the knowledge repository can interact with the engineering system for updating information regarding selected elements and interacting with the runtime system to collect execution information for use in subsequent application developments | 06-19-2014 |
| 20140181791 | SOFTWARE DEVELOPMENT WORK ITEM MANAGEMENT SYSTEM - A software development management system for use by multiple developers includes an acquisition unit configured to acquire, for each of a plurality of work items each representing a work to change at least one file, designation of a file associated with the work item. A dependency detection unit detects dependencies among a number of files. A determination unit determines, on the basis of the dependencies among the files, whether there is a dependency relationship between at least two work items based on the dependency relationship between the files detected by the dependency detection unit. | 06-26-2014 |
| 20140189644 | ADDITIVE INDEPENDENT OBJECT MODIFICATION - Disclosed is a method, a system and a computer readable medium for additive independent object modification. The method includes determining an association between an independent object modification and a base object of a software application, modifying at least one element of the base object based on the associated independent object modification, and configuring the software application to execute in a computer system using the modified base object. | 07-03-2014 |
| 20140189645 | METHOD FOR DYNAMIC CONFIGURATION MANAGEMENT AND AN APPARATUS THEREOF - The present invention relates to a dynamic configuration management method providing an automatically updated configuration management structure ( | 07-03-2014 |
| 20140215436 | MANAGING CHANGE-SET DELIVERY - An approach that analyzes and manages unresolved (i.e., pending, outgoing) change-sets is provided. Specifically, this approach parses the change-set into a plurality (i.e., one or more) of changes to determine the impact each change may have. An alert may be provided to the user indicating whether the change-set should be checked-in based on the determined impact. Specifically, a change-set management tool provides this capability. The change-set management tool includes a parsing module configured to receive an outgoing change-set; and parse the change-set into a plurality of changes. The change-set management tool further comprises an evaluation module configured to evaluate an impact that each of the plurality of changes within the change-set has on other changes of the plurality of changes within the change-set. | 07-31-2014 |
| 20140237448 | BI-DIRECTIONAL LINKING OF PRODUCT BUILD INFORMATION - Software product build information is bi-directionally linked. At least a first build instance of the software product is built and the first build instance is published by a supplier build repository. Responsive to an entity who is not the supplier indicating a use of the first build instance in a client product, build information relating to the use of the first build instance in the client product is received. The build information relating to the use of the first build instance in the client product is published by the supplier build repository. | 08-21-2014 |
| 20140245263 | DEVELOPMENT, PROGRAMMING, AND DEBUGGING ENVIRONMENT - A method includes receiving hardware description code that generically describes circuitry, and translating the hardware description code into one or more configuration files specific to a programmable system. The method further includes generating program code for a microcontroller of the programmable system based, at least in part, on the hardware description code, and configuring the programmable system to implement the circuitry according to the configuration files and the program code. | 08-28-2014 |
| 20140250425 | Systems and Methods for Enabling and Configuring Tracking of User Interactions on Computer Applications - Methods and systems for tracking user interactions with a computer application. As a computer application is used, it keeps track of user interactions, for example, for use on an analytics server. An interaction tracking configuration may specify which events are tracked, under what conditions the events are tracked, and identify what information is recorded. This configuration may be separated from the application. For example, the configuration may be stored in a configuration file at a location specified within and used by an application. The configuration may then be changed without changing a deployed application. Certain embodiments provide a tracking configuration tool to facilitate the creation of such a configuration. The tool may use a running application to identify events for tracking. Identifying events in this way can simplify the task of configuring interaction tracking by reducing the need for understanding or accessing of the actual code of the application. | 09-04-2014 |
| 20140258983 | MODEL FOR CONFIGURATION INDEPENDENT PROCESS TEMPLATES AND BUSINESS CATALOG - A system and method for facilitating configuring service references to be called by a software application. An example method includes providing a catalog of processes, wherein the catalog of processes includes information identifying one or more services to be called to implement one or more processes; determining one or more service references occurring in a business process template that are used to implement one or more processes identified in the catalog of business processes; interchanging the one or more service references with one or more tokens in the process template, resulting in a tokenized template in response thereto; and running one or more processes in accordance with the tokenized template. In a more specific embodiment, the example method further includes employing a build system implemented via middleware to tokenize the process template to yield the tokenized template in response thereto. | 09-11-2014 |
| 20140258984 | SOFTWARE CONFIGURATION CONTROL WHEREIN CONTAINERS ARE ASSOCIATED WITH PHYSICAL STORAGE OF SOFTWARE APPLICATION VERSIONS IN A SOFTWARE PRODUCTION LANDSCAPE - According to some embodiments, a source version of a software product may be established in connection with a software production landscape. A first container, representing a first uniquely addressable physical location in the software production landscape, may then be associated with the source version. An executable derivative version of the software product may be built from the source version, and a second container, representing a second uniquely addressable physical location in the software production landscape, may be associated with the executable derivative version. Software configuration information may then be automatically provided to a user based at least in part on a relationship between the first and second containers at a given point in time. | 09-11-2014 |
| 20140282397 | SOURCE CONTROL OF CUSTOM CODE IN A BACKEND-AS-A-SERVICE MODULE - Techniques are described herein that are capable of providing source control of custom code in a backend-as-a-service (BaaS) module. For instance, the custom code may be automatically loaded dynamically (e.g., on-demand) in a runtime that is hosted by the BaaS module while the runtime is running to provide custom backend features that are defined by the custom code to an application in response to receipt of a request from the application. Source control of the custom code may be provided without providing source control of host code that defines the runtime. | 09-18-2014 |
| 20140282398 | PLATFORM FOR DEVELOPING AND DISTRIBUTING MOBILE APPLICATIONS - 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. Configurable user interface components and functional components are available to a developer to create packages of components, which packages and components are available and configurable to create products. The developer can associate the product with one or more endpoints to result in an application associated with each endpoint. Updating the applications requires only modifications to the product or its underlying packages and/or components, but not to each of the applications resulting from the association of the product with the one or more endpoints. | 09-18-2014 |
| 20140289703 | Methods and Systems for Physically-Based Runtime Effects - One exemplary embodiment involves receiving input defining an inverse kinematics hierarchy for an object to be displayed in an application under development. The exemplary embodiment further involves receiving input indicating a physical parameter applicable to the inverse kinematics hierarchy. The exemplary embodiment further involves producing a package defining the application under development. The package comprises a description of the physical parameter and code that, when executed or interpreted, provides a physics engine configured to calculate a physical response of at least a portion of the inverse kinematics hierarchy using the description of the physical parameter. | 09-25-2014 |
| 20140298290 | IDENTIFICATION OF CODE CHANGES USING LANGUAGE SYNTAX AND CHANGESET DATA - A computer retrieves a first changeset that is associated with a program. The computer identifies a first set of changes included in the first changeset based on a time stamp of a change, textual matching, and syntactical matching. The computer identifies a first area of interest within a source code of the program based, at least in part, on the first set of changes. The computer searches for a second set of changes based, at least in part, on the first area of interest. The computer generates a result that includes, at least in part, the first set of changes. | 10-02-2014 |
| 20140298291 | CHANGE METHOD, APPARATUS, AND RECORDING MEDIUM - A method performed by a computer, the method includes: determining a portion of a program run by a first information processing apparatus, the portion corresponding to a difference between first configuration information related to the first information processing apparatus and second configuration information related to a second information processing apparatus; and deciding a change type to be applied to the portion of the program, based on details of the difference. | 10-02-2014 |
| 20140298292 | Accelerated Software Services Delivery System - A system and computer implemented method for producing a user configuration profile of a software configuration including software configuration modifications selected by a user which read by an installer engine in comparison to the software configuration allows installation of an updated software configuration including the software configuration modifications selected by the user. | 10-02-2014 |
| 20140298293 | SYSTEM FOR GENERATING APPLICATION SOFTWARE - An application generation system configured to automatically generate an application having a desired function is disclosed. The application generation system has a mobile terminal including computation means for performing predetermined computation processing, image capture means for capturing an information code, decoding means for decoding the information code to extract character information, display means for displaying predetermined information, and first communication means for communicating character information. The system includes a server having second communication means for communicating with the first communication means, an assessment database storing assessment rules, a program component database storing program components, and analysis means which analyzes character information received by the second communication means to determine results of the analysis based on the assessment rules stored in the assessment database to determine information related to attributes and configuration of an application to be generated as well as program components configuring the application. | 10-02-2014 |
| 20140304683 | METHOD, SERVER AND COMPUTER-READABLE RECORDING MEDIA FOR MANAGING METASTORE - A method for managing a metastore includes steps of: (a) registering static resource and metadata at a metastore to produce a certain application by using an open device API and external HTML5 authoring tools; (b) configuring a build target operating system and a build target platform; (c) checking a degree of matching between i) the static resource and the metadata and ii) information on parameters delivered from a build target metarepository by referring to the configured build target operating system and platform; (d) calling an external open build system and an API, if the degree of matching is satisfied, and then creating and receiving a target executable file in return to fit for the configured build target operating system and platform; and (e) storing the target executable file, the static resource and the metadata in a metasource repository. | 10-09-2014 |
| 20140310687 | DATABASE SERVER AND PROGRAM PACKAGE INTEGRATING METHOD - A database server communicates with a plurality of client devices. Each of the client devices is used to create a program package to cooperatively develop a software project. An integrating package is created in a storage of the database server. When two or more client devices simultaneously access the integrating package, a storage region is created for each of the two or more client devices in a storage space of the integrating package. When the two or more client devices write the program package to the integrating package, the program package of each of the two or more client devices is automatically written into a corresponding storage region. | 10-16-2014 |
| 20140317599 | Synchronization Modules for Programmable Hardware and Use - Customizing a target system. The target system may include a first device with a first programmable hardware element (PHE) and a second device with a second PHE. Synchronization modules may be provided for implementation on the first and second PHEs. The synchronization modules may provide a standard interface for interacting with other code. A user may specify user-created code for the first and second PHEs which utilizes the synchronization modules. The user-created code may interact with the synchronization modules using the standard interface. Accordingly, hardware descriptions may be generated for the first and second PHEs of the target system. Different modules may be used for different interconnects. Additionally, multiple synchronization modules may be used, e.g., dynamically, during operation of the target system. | 10-23-2014 |
| 20140344782 | CONCEPTUAL SERVICES IMPLEMENTATION PLATFORM - The present disclosure generally relates to computing methods and applications. A service platform includes standard functionalities that can be used in different applications, such as composite applications. The service platform includes a database that stores application specific information, which is mapped to the standard functionalities. To use these functionalities, different applications initialize relevant parts of the database and use predefined standards to access these functionalities. | 11-20-2014 |
| 20140351791 | CONFIGURABLE SOFTWARE APPLICATION - A configurable software application is provided, where the software application may be designed on a platform including at least one configuration utility for enabling end users to customize various aspects of the application. For example, end users may use the configuration utility to customize one or more user interface elements, event handlers, data handlers, and/or data elements of the application. The software application may be automatically updated to incorporate the user customizations. In one implementation, custom user interface elements may be used to control a navigation of the application or an interaction with data elements of the application. In another implementation, custom data elements, based on a hierarchical metadata structure, may dictate an organization of the application. In another implementation, custom event handlers may control business logic and rules for the application, while custom data handlers may control interfacing with the data elements. | 11-27-2014 |
| 20140359576 | APPLICATION BUILDING BLOCKS FOR ON DEMAND AND ON PREMISE USAGE - The disclosure generally describes computer-implemented methods, software, and systems for enhancing visual applications. A computer-implemented method includes: identifying a map-based application for enhancement, identifying a configuration file defining one or more application parts for enhancing the map-based application, the one or more application parts associated with a second application, and incorporating the one or more application parts from the identified configuration file into the map-based application. In some instances, incorporating the one or more application parts into the map-based application includes identifying a symbol associated with each of the one or more application parts, accessing data from the second application associated with each of the one or more application parts, and inserting an instance of the symbol for each application part based on the accessed data from the second application. | 12-04-2014 |
| 20140372980 | AUTOMATIC CUSTOMIZATION OF A SOFTWARE APPLICATION - A method for configuring a software application. The method includes obtaining user profiles each containing attribute values corresponding to a portion of an attribute list, identifying a user subset having same attribute values for a particular portion of the attribute list and forming an attribute signature, analyzing the configuration setting used by each user in the user subset to generate a statistical measure representing the user subset configuring the software application, matching a new user profile to the attribute signature of the user subset, presenting, to the new user and in response to the matching, the statistical measure representing the user subset configuring the software application, and receiving, in response to presenting the statistical measure, an approval from the new user to customize the software application, where the software application is automatically customized based on the statistical measure representing the user subset configuring the software application. | 12-18-2014 |
| 20140372981 | AUTOMATIC CONFIGURATION OF MOBILE PROGRAMS - The subject matter disclosed herein provides methods for automatically configuring a mobile program based on a customer's access to one or more applications. This method may maintain metadata for a mobile program in a directory. The mobile program may be configured to provide one or more services when installed on a mobile device. Each service may be associated with one or more applications. Customer landscapes identifying applications accessible by a customer may be maintained in the directory. A program identifier may be received from a mobile device of the customer. The program identifier may identify a mobile program installed on the customer's mobile device. A configuration file may be generated based on the received program identifier and transmitted to the customer's mobile device. Related apparatus, systems, techniques, and articles are also described. | 12-18-2014 |
| 20140372982 | STANDARDIZATION OF VARIABLE NAMES IN AN INTEGRATED DEVELOPMENT ENVIRONMENT - A method for providing for standardization of variable names in an integrated development environment is provided. The method includes scanning a project source code for variable names, where the project source code is managed by a development team in an integrated development environment. The method includes determining that the project source code contains a non-standard variable name, where the distinction between a standard variable name and the non-standard variable name is defined by a set of standards and semantic rules. The method then includes identifying a location of the non-standard variable name in the project source code. | 12-18-2014 |
| 20150026662 | Method And Apparatus For Configuring Control Software For Radar Systems Having Different Hardware Architectures And Related Software Products - Techniques and systems are provided for generating radar control software for radar systems having a variety of different hardware architectures in an efficient manner. A base radar control program may be provided, that is configurable using architecture-specific configuration data. A database may also be provided, that includes configuration data associated with a plurality of different radar system architectures. Radar control software may be generated for a radar system of interest by retrieving configuration data associated with a corresponding hardware architecture from the database and using the data to configure the base radar control program. | 01-22-2015 |
| 20150026663 | MOBILE APPLICATION OPTIMIZATION PLATFORM - A device may receive configuration information for an experiment associated with optimizing an application. The configuration information may identify a group of experimental treatments and information identifying a target event. The device may identify an experimental treatment to be implemented in the application, and may implement the experimental treatment in the application. The device may collect response information based on implementing the experimental treatment. The device may detect the target event associated with the experiment, indicating that the response information is to be provided to an experiment server. The device may determine that the experiment server is unreachable and may store the response information. The response information may be stored to allow the response information to be provided to the experiment server at a later time. The response information may be provided to the experiment server to permit the experiment server to determine a result of the experiment. | 01-22-2015 |
| 20150040103 | DATA COMPONENT IN A MOBILE APPLICATION FRAMEWORK - In an example embodiment, one or more configuration files are defined for an extensible application, the one or more configuration files including metadata for the extensible application. Then code defining behavior of the extensible application is combined with a mobile application framework, the mobile application framework including a data component configured to obscure details of an underlying data source for the extensible application, the code including calls made to one or more of the generic components. The code is compiled and one or more of the configuration files can be uploaded to a mobile platform server for storage. Then the compiled code is uploaded to a platform server for distribution to one or more devices. One or more of the configuration files is configured to alter an aspect of the extensible application. Finally, the altered one or more configuration files is uploaded to the mobile platform server for storage. | 02-05-2015 |
| 20150040104 | TILES IN A MOBILE APPLICATION FRAMEWORK - In an example embodiment, a mobile application framework is added to a metadata-driven application. The mobile application framework includes generic libraries having one or more references to one or more configuration files stored on a platform server. Then the one or more configuration files can be updated to include one or more tiles, each tile comprising a user interface element or screen view, each tile being either a primitive tile or a tile embedding other nested tiles within it, thereby updating the metadata-driven mobile application without recompiling it. | 02-05-2015 |
| 20150067641 | Behavioral Extensibility for Mobile Applications - In example embodiments, systems, methods, devices, and machine-readable media for creating and/or executing extensible mobile applications are provided. Extensibility of a mobile application deployed on a device is achieved with configuration files that can be provided to the device at a time after initial deployment of the application. Mobile application framework components combined with the code of the application enable extracting Java scripts from the configuration files, and executing the Java scripts to thereby alter the behavior of the application. | 03-05-2015 |
| 20150067642 | DEVELOPMENT, TEST AND DEPLOYMENT OF APPLICATIONS - A method for developing an application comprises: one or more processors selecting at least one service associated with an application; and one or more processors creating a binding between the application and the at least one service. Creating the binding is performed by generating, in association with the application, a profile for the at least one service, where the profile contains at least one parameter associated with the at least one service. One or more processors automatically instantiate the at least one parameter in the at least one service based on an environment in which the application runs. | 03-05-2015 |
| 20150067643 | BI-DIRECTIONAL COMMUNICATION BETWEEN CHANGE MANAGEMENT TOOL AND IMPLEMENTATION TOOLS - Task implementation tools are registered to interface with a change management tool. The change management tool configures a plurality of tasks to implement a change to an information technology infrastructure's configuration, and sends a plurality of task instructions to the plurality of task implementation tools for performing the plurality of tasks. Each task instruction is directed to a targeted task implementation tool for performing a particular task and includes task-related information for the targeted implementation tool to perform the particular task. Registering the plurality of task implementation tools to interface with the change management tool includes registering each the plurality of task implementation tools to accept the task instruction for the particular task directed to it from the change management tool, to know what to do with the task instruction and to know how to respond to the task instruction. | 03-05-2015 |
| 20150074640 | RUNTIME DETECTION OF SOFTWARE CONFIGURATIONS AND UPGRADES - The present disclosure relates generally to the field of software configuration management, and more particularly to validating, detecting, and dynamically handling software configurations and updates. A computing device detects a configuration event in a first computer program. The computing device includes a plurality of executing computer programs, wherein the plurality of executing computer programs includes the first computer program and a second computer program, and wherein the first computer program has a configurational relationship to the second computer program. The computing program determines whether the configuration event affects the second computer program. The computing device generates an action in response to the determination. | 03-12-2015 |
| 20150074641 | FUNCTIONAL RULE AND COMPONENT STORAGE - A method of managing software design specifications with functional rule versioning may include storing references to a plurality of software components in a database system, and storing references to a plurality of functional rules in the database system. In some embodiments, the functional rules may define behaviors that may be assigned to the plurality of software components. The method may also include receiving a selection of one or more software components from the plurality of software components. The one or more software components may define a software product. The method may additionally include receiving assignments of the plurality of functional rules to the one or more software components, and providing an interface for navigating through the one or more software components and editing the assignments. | 03-12-2015 |
| 20150074642 | OBJECT DESIGN - Described herein are systems, methods and apparatuses that can provide a holistic, bottom-up approach to facilitate the design of objects (e.g., modular objects that can facilitate industrial automation applications). The design approach includes selection of an object from a library of a plurality of objects; filtration of functionalities of the object based on a workflow of an application; and display of the object for customization of the object for the application with the filtered functionalities masked. | 03-12-2015 |
| 20150089474 | RUNTIME GENERATION AND INJECTION OF JAVA ANNOTATIONS - An annotation generator utility is implemented. The annotation generator utility reads, from a properties file, configurations of a Java component. The annotation generator utility generates annotations corresponding to the configurations. The annotation generator utility injects the annotations into compiled source code of the Java component. In one aspect, the annotations are injected into compiled source code of the Java component at build time. In another aspect, the annotations are injected into compiled source code of the Java component at runtime. | 03-26-2015 |
| 20150089475 | RUNTIME CUSTOMIZATION INFRASTRUCTURE - In various embodiments, methods, systems, and non-transitory computer-readable media are disclosed that allow developers to allow runtime customizations of documents developed using a desktop integration framework. Workbook metadata is a set of information that describes how a given workbook is integrated with a particular web application. When a workbook is being published, metadata may be written into a local cache in the published workbook as well as a workbook definition file. Metadata management may be handed by a metadata service allowing updates and customization of published workbooks independently of a local cache in the published workbook and the workbook definition file. | 03-26-2015 |
| 20150100945 | RESUMING A SOFTWARE BUILD PROCESS - A computer resumes a software build process following a build process fail. Upon a failure of a build process executing a build plan, the computer saves the state of the build process. After the computer receives an indication from a versions control system that a source code module has been checked-in, the computer determines the modules in the build plan that are dependent on the checked-in source code file. The computer creates an interim build plan based, at least in part, on the determined modules in the build plan that are dependent on the checked-in source code module and the saved state of the build process. The computer then automatically executes the interim build plan. | 04-09-2015 |
| 20150113506 | METHOD AND SYSTEM FOR ADAPTIVE LOADING OF APPLICATION - A system and method of adaptively loading a target application is described herein. The method can include the steps of loading an encapsulation application into memory in which the encapsulation application encapsulates the target application and allocating memory for the encapsulated target application. The method can also include the steps of remapping the encapsulated target application into the allocated memory such that the target application is loaded in the memory and configuring the target application to enable calls of the target application to be intercepted by the encapsulation application. | 04-23-2015 |
| 20150113507 | METHOD FOR AUTOMATIC GROUPING OF INTERLINKED GRAPHICAL CONFIGURATION ELEMENTS AND COMPUTER PROGRAM PRODUCT - The present disclosure relates to a method and computer program product for grouping a plurality of interlinked graphical configuration elements (GCEs) into a resulting graphical functional element (GFE). The method and computer program product receive a selection of the plurality of interlinked GCEs to be grouped. The method and computer program product create the resulting GFE by: identifying inputs and outputs of the plurality of GCEs; identifying from the inputs and outputs root inputs and exiting outputs; generating for each root input/exiting output a root input/exiting output graphical representation identifier in the resulting GFE; generating the resulting GFE including the root input/exiting output graphical representation identifiers; graphically linking the root input/exiting output graphical representation identifiers to corresponding GCEs outside of the plurality of interlinked GCEs; and displaying the resulting GFE in replacement of the plurality of interlinked GCEs. | 04-23-2015 |
| 20150113508 | PROCESSING PROPOSED PROGRAM CODE LIBRARIES IN A NETWORKED COMPUTING ENVIRONMENT - An integrated development environment (IDE)-based approach for processing/analyzing proposed program code libraries as a replacement for existing program code libraries in a networked computing environment is provided. A set of annotations associated with a set of program code files and a proposed (e.g., new, modified, etc.) program code library are received in an integrated development environment (IDE). It may then be determined whether the proposed program code library is an excluded program code library based on the set of annotations. It may also be determined whether the proposed program code library meets one or more thresholds for replacing an existing program code library. If the proposed program code library is not excluded and meets the threshold(s), the proposed program code library may then be provided to a computer device hosting the IDE (e.g., for implementation). | 04-23-2015 |
| 20150121340 | ASSOCIATING A VISUALIZATION OF USER INTERFACE WITH SOURCE CODE - Visualizing user interfaces specified by source code includes executing, using a development application, source code including a segment of source code specifying a user interface and, responsive to executing the segment of source code, generating, using a processor, a first screenshot including the user interface. The first screenshot is correlated with the segment of source code. The first screenshot is stored in association with the segment of source code. | 04-30-2015 |
| 20150121341 | ASSOCIATING A VISUALIZATION OF USER INTERFACE WITH SOURCE CODE - Visualizing user interfaces specified by source code includes executing, using a development application, source code including a segment of source code specifying a user interface and, responsive to executing the segment of source code, generating, using a processor, a first screenshot including the user interface. The first screenshot is correlated with the segment of source code. The first screenshot is stored in association with the segment of source code. | 04-30-2015 |
| 20150143335 | SYSTEM AND METHOD FOR IDENTIFYING, ANALYZING AND INTEGRATING RISKS ASSOCIATED WITH SOURCE CODE - The various embodiments herein provide a system and method for identifying, analyzing and integrating the risks associated with a source code. The system comprises a code coverage module for collecting and transforming the code coverage information by a file name, a source code analyzer module for collecting and transforming source code violations information by the file name, a software configuration management module for collecting and transforming the source code commit information by the file name, a risk analyzer processing module for receiving and relating the collected code coverage information, source code violations information and source code commit information with each other by the file name and a report generation module for publishing the processed result of the collected code coverage information, source code violations information and source code commit information in a report. The report is reviewed for identifying, analyzing and integrating risks associated with source code. | 05-21-2015 |
| 20150143336 | SOFTWARE CONFIGURATION CONTROL WHEREIN CONTAINERS ARE ASSOCIATED WITH PHYSICAL STORAGE OF SOFTWARE APPLICATION VERSIONS IN A SOFTWARE PRODUCTION LANDSCAPE - According to some embodiments, a source version of a software product may be established in connection with a software production landscape. A first container, representing a first uniquely addressable physical location in the software production landscape, may then be associated with the source version. An executable derivative version of the software product may be built from the source version, and a second container, representing a second uniquely addressable physical location in the software production landscape, may be associated with the executable derivative version. Software configuration information may then be automatically provided to a user based at least in part on a relationship between the first and second containers at a given point in time. | 05-21-2015 |
| 20150293765 | Vehicle Configuration Driven Loading of Software Parts - A system and method of loading software parts on a vehicle. Information identifying a desired software configuration for active software parts on the vehicle is received by a processor unit. The processor unit identifies a current software configuration of the active software parts on the vehicle. The processor unit determines a dataload plan for loading the software parts on the vehicle based on a difference between the desired software configuration and the current software configuration. The dataload plan identifies an order for loading the software parts on the vehicle. The dataload plan is used for loading the software parts on the vehicle to make the software parts active on the vehicle. | 10-15-2015 |
| 20150309789 | MODIFYING MOBILE APPLICATION BINARIES TO CALL EXTERNAL LIBRARIES - A method includes determining a system library method based on a configuration file in an application library. The method also includes generating a wrapper method for the system library method, wherein the wrapper method includes a first instruction to invoke the system library method, and a second instruction to invoke a method in an external library. The method further includes replacing a third instruction that invokes the system library method with a fourth instruction that invokes the wrapper method. A binary class in a plurality of binary classes in the application library comprises the third instruction. | 10-29-2015 |
| 20150309790 | 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 T is 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. | 10-29-2015 |
| 20150309791 | DYNAMICALLY RECOMMENDING CHANGES TO AN ASSOCIATION BETWEEN AN OPERATING SYSTEM IMAGE AND AN UPDATE GROUP - Dynamically recommending changes to an association between an operating system image and an update group includes monitoring a configuration of a deployed copy of a first master operating system (OS) image; detecting a modification in the configuration of the deployed copy; determining that the configuration of the deployed copy with the modification more closely matches a configuration of a second master OS image than a configuration of the first master OS image; in response to determining that the configuration of the deployed copy with the modification more closely matches the configuration of the second master OS image, generating an association recommendation that recommends associating the deployed copy with a second update group of the second master OS image; and associating the deployed copy with the second update group of the second master OS image instead of the first update group of the first master OS image. | 10-29-2015 |
| 20150317155 | Editing Multiple Attributes of Multiple Assets in an Editor - A system and a method are disclosed for taking data input from, and writing data back to, multiple sources that are composed of multiple types of storage types and configurations. This data is revision controlled and presented to the user in a unified table format for ease of correlation. The received data also can be modified or otherwise changed and written back to the disparate sources from which the data was obtained. | 11-05-2015 |
| 20150324178 | HASH-BASED CHANGE TRACKING FOR SOFTWARE MAKE TOOLS - A request handler may receive a request for a make operation for generating executable code from a plurality of source files and associated dependences there between, the source files and associated dependences having been previously utilized to generate a previous version of the executable code. A hash comparator may then determine, for a selected source file, that a current hash value corresponding to current content of the selected source file is different from a previous hash value corresponding to previous content of the selected source file during the previous utilization, whereupon the hash comparator may proceed to initiate execution of the make operation using the current content of the selected source file, based on the difference between the current hash value and the previous hash value. | 11-12-2015 |
| 20150339119 | System and Method Thereof for Creating Dynamically Attachable and Detachable Binary Files - A technique for creating dynamically attachable and detachable binary files is provided. The invention provides an efficient mechanism to manage the existing code bases with respect to the additional code needed for a particular feature as a single code base. It also provides a mechanism for designers to plan for such features even before the code is conceptualized. The system parses the code having a dynamic feature manager (DFM) tag to produce a base code wherein the DFM tag encloses a feature. The multiple code sets based on the DFM tags are created. A feature change table storing the information about a changed feature compared to the feature from the code sets is generated and stored in the system. The code sets are then compiled to generate binaries. The difference between each of the binaries, using the feature change tables is determined and stored which is used for creating differential binary file(s). | 11-26-2015 |
| 20150363179 | Platform on a Platform System - A platform on a platform system has a first platform that provides deployment and configuration settings for applications developed on the platform; and a second platform developed using the deployment and configuration settings provided by the first platform. The second platform provides second deployment and second configuration settings, and the second platform also provides services that allow second applications to interact with the first platform through the second platform services. | 12-17-2015 |
| 20150363195 | SOFTWARE PACKAGE MANAGEMENT - Systems and methods for software package management are provided to avoid dependency conflicts that occur when running software packages. According to one embodiment of this disclosure, there is provided a computer-implemented method for organizing a plurality of software modules. The method can include receiving a request for organizing the plurality of software modules, determining a dependency relationship between the plurality of software modules, creating or updating a file system of nested folders based on the dependency relationship between the plurality of software modules, and storing the plurality of software modules in the file system of nested folders, wherein each folder is associated with one of the software modules based on the dependency relationship between the plurality of software modules. | 12-17-2015 |
| 20150370540 | Method of developing an application for execution in a workflow management system and apparatus to assist with generation of an application for execution in a workflow management system - This disclosure provides techniques for facilitating workflow design and modification in a workflow management system. In one embodiment, software provides a design interface to an application developer to streamline transition definition and associated conditions and other parameters between phases of a workflow (and related rework for workflow modification), without requiring substantial manual recoding. The workflow management system accepts consequent data as metadata, which the system uses to enforce both state and required transition conditions to regulate how end-users interact with a database. The metadata is invoked during workflow execution in a manner tied to any desired condition and, thus, desired context. | 12-24-2015 |
| 20160011865 | BUILDING A PATTERN TO DEFINE A TOPOLOGY AND APPLICATION ENVIRONMENT USING SOFTWARE COMPONENTS AND SOFTWARE UPDATES/FIXES FROM EXTERNAL REPOSITORIES FROM MULTIPLE VENDORS | 01-14-2016 |
| 20160011866 | BUILDING A PATTERN TO DEFINE A TOPOLOGY AND APPLICATION ENVIRONMENT USING SOFTWARE COMPONENTS AND SOFTWARE UPDATES/FIXES FROM EXTERNAL REPOSITORIES FROM MULTIPLE VENDORS | 01-14-2016 |
| 20160019047 | OPTIMIZED DELIVERY OF WEB APPLICATION CODE - Application code for deployment to a client over a data link is optimized to minimize download time by supplying only the application code with a particular object that is required by the object. In a web application that includes multiple pages, the HTML and JAVASCRIPT are scanned to identify code resources called by a particular web page. When all called resources are identified, they are extracted and concatenated into a single resource file. When the page is downloaded to the client, the import file is included with the page. The import file may be cached so that it need only be downloaded once, rather than being downloaded every time the page is requested. The invention is suitable for use with other interpreted scripting languages. | 01-21-2016 |
| 20160026462 | APPLICATION WRAPPING FOR APPLICATION MANAGEMENT FRAMEWORK - Methods and systems for developing, modifying, and distributing software applications for enterprise systems are described herein. A software component, such as a native mobile application or a template application, may be modified into a managed mobile application, and metadata associated with the managed mobile application may be generated. The managed application and associated metadata may be provided to one or more application stores, such as public application stores and/or enterprise application stores. Managed applications and/or associated metadata may be retrieved by computing devices from public application stores and/or enterprise application stores, and may be executed as managed applications in an enterprise system. | 01-28-2016 |
| 20160034285 | Extending JAVA Application Functionality - Methods and systems for extending functions of a JAVA application. The JAVA application may call a browser to obtain the global configuration file that is indicated by a URL and load configuration information of extensions of the JAVA application based on the global configuration file. In response to a user request received by the JAVA application, the JAVA application calls a browser and processes the user request based on the loaded configuration information of extensions of the JAVA application. In implementations, the JAVA application may transmit the user request to a server. After receiving a response to the user request from the server, the JAVA application may process the response to the user request based on the loaded configuration information of extensions of the JAVA application. The implementations may respond to the user request that is beyond the preset functions of the JAVA application. | 02-04-2016 |
| 20160062740 | VALIDATING AND MAINTAINING RESPECTIVE VALIDATION STATUS OF SOFTWARE APPLICATIONS AND MANUFACTURING SYSTEMS AND PROCESSES - Validating and maintaining respective validated status of software applications and manufacturing systems and processes is presented herein. A validation system can comprise a mapping component configured to extract, from a set of requirement specification documents, individual requirement specifications; and extract, from a set of test function documents, test steps. Further, the validation system can comprise a tracing component configured to generate a trace matrix associating the individual requirement specifications with respective test steps of the test functions or respective documents of the set of requirement specification documents. In an aspect, the validation system can enforce, via respective object linking and embedding control extensions, respective roles of authors, reviewers, and approvers of the set of requirement specification documents. In another aspect, the validation system can electronically receive and insert test results in the set of test function documents. Further, the validation system can perform automated validation of software in execution. | 03-03-2016 |
| 20160062764 | SOFTWARE COMPONENT CONFIGURATION IDENTIFICATION - An identification method is provided. The method includes generating dictionaries comprising a product taxonomy and associated base entities comprising sub-sets within a plurality of software products. Data entities are located from unstructured text of the dictionaries. Locating the data entities includes locating long distance word matches within the unstructured text. Ontologies are populated with the entities and relationships between the data entities are determined. | 03-03-2016 |
| 20160062766 | UNIFORM REFERENCES - Embodiments of the present invention provide a novel and non-obvious method, system and computer program product for uniform references to artifacts in a software configuration management tool. In one embodiment, a data processing system configured to resolve artifact references can include a software configuration management tool and uniform reference resolution logic coupled to the tool. In this regard, the uniform reference logic can be programmed to resolve a path name to a referenced artifact by processing a uniform reference specifying the referenced artifact. | 03-03-2016 |
| 20160063282 | DEPENDENCIES BETWEEN FEATURE FLAGS - An example method for handling dependencies between feature flags can include defining, by a processing resource executing instructions, dependencies between a plurality of feature flags in a process executable by the processing resource. The method can include enforcing, by the processing resource executing instructions, the dependencies during activation of a first feature by a determination of validity of utilization of a feature flag as a switch for a second feature. | 03-03-2016 |
| 20160070566 | MODEL ELEMENTS IN SOFTWARE TOOLS AS AUTOMATONS IN A SOFTWARE CUSTOMIZATION SYSTEM AND METHOD - Presented is a system and method for the integration of existing software development tools into a software customization system, where each software development tool has its own model of its software artifacts. The invention allows models in an external software development tool to become software artifacts within a software customization system, and also allows the model elements of the existing tools to become automatons. | 03-10-2016 |
| 20160085545 | METHOD AND APPARATUS FOR IMPLEMENTING INTER-COMPONENT FUNCTION CALLS - A method of implementing inter-component function calls. The method comprises generating a lower tier indirection data structure comprising an entry indicating a location in memory of a function within a first software component, a higher tier indirection data structure comprising an entry indicating a location in memory of the lower tier indirection data structure, and a configuration data structure comprising an entry defining an active version of the first software component. The method further comprises implementing executable computer program code for an inter-component function call by referencing entries within the configuration data structure, the higher tier indirection data structure and the lower tier indirection data structure. | 03-24-2016 |
| 20160092207 | DATACENTER CONFIGURATION MANAGEMENT TOOL - A system may include a first point of deployment (POD) and a second POD at a data center, where each of the first POD and the second POD may be configured to support a first version of a platform template. The first POD may a first set of servers based on a first hardware platform and the second POD may include a second set of servers based on a second hardware platform. A configuration manager may be configured to determine a difference between the first hardware platform and the second hardware platform and generate a second version of the platform template based on the difference between the first hardware platform associated and the second hardware platform. In some cases, the second version of the platform template may be installed on the second POD as part of an upgrade process | 03-31-2016 |
| 20160092208 | MANAGING ACCESS TO RESOURCE VERSIONS IN SHARED COMPUTING ENVIRONMENTS - The disclosed embodiments provide a system that manages access to resource versions in a shared computing environment. Routing data including locations of the resource versions is used to route a request to a resource version in the shared computing environment. For an application that is implemented by a set of resources, the routing data and the request is used to execute the application using an alternative version of a resource that is under test and default versions of other resources that are not under test. | 03-31-2016 |
| 20160092210 | CREATION OF A SOFTWARE CONFIGURATION SIGNATURE FOR SOFTWARE - Techniques are described for generating configuration level signatures. In an embodiment, one or more computing devices are used to generate a first signature for a particular software deployment that is configured at a particular configuration level. The first signature is generated based on digest information that identifies a plurality of deployed source components for the particular software deployment. Mapping data is stored that maps the first signature to the digest information identifying the plurality of deployed source components for the particular software deployment. A second signature is generated based on information that defines target source components for a set of software deployments that includes the particular software deployment. The first signature is compared with the second signature to determine whether the deployed source components satisfy the target source components. An indication of whether the deployed source components satisfy the target source components is stored. | 03-31-2016 |
| 20160103667 | Configuration Transform for Application Deployment - Creating a deployment package for deploying an application. The method includes identifying a configuration dataset The method further includes identifying a plurality of target environments. The method further includes transforming the configuration dataset, during build time, for each of the target environments to create a plurality of different configuration datasets corresponding to the different target environments. The method further includes packaging the plurality of configuration datasets with a deployable application entity to create a package that can be deployed to a plurality of different targets to make application deployment across multiple targets more efficient. | 04-14-2016 |
| 20160110187 | PARALLEL DEVELOPMENT OF DIVERGED SOURCE STREAMS - Methods and systems may provide for tracking, on a position-by-position basis in a diverged code history associated with a diverged source stream, an origin source stream and an original position of code contained within the diverged source stream. Additionally, a modification may be detected with respect to a first portion of the code contained within the diverged source stream at a first position. In such a case, the modification and the first position may be automatically documented in the diverged code history. | 04-21-2016 |
| 20160110189 | PARALLEL DEVELOPMENT OF DIVERGED SOURCE STREAMS - Methods and systems may provide for tracking, on a position-by-position basis in a diverged code history associated with a diverged source stream, an origin source stream and an original position of code contained within the diverged source stream. Additionally, a modification may be detected with respect to a first portion of the code contained within the diverged source stream at a first position. In such a case, the modification and the first position may be automatically documented in the diverged code history. | 04-21-2016 |
| 20160124743 | COMPATIBILITY AND OPTIMIZATION OF WEB APPLICATIONS ACROSS INDEPENDENT APPLICATION STORES - Systems and methods may provide for identifying a set of configuration options associated with a plurality of different application stores and using the set of configuration options to generate one or more compatibility suggestions for a web application in a development environment. Additionally, the set of configuration options may be used to generate one or more optimization suggestions for the web application in the development environment, wherein the one or more compatibility suggestions and the one or more optimization suggestions may be specific to a particular application store in the plurality of different application stores. In one example, runtime information associated with web application is identified, wherein the runtime information is used to generate at least one of the one or more optimization suggestions. | 05-05-2016 |
| 20160124744 | SUB-PACKAGING OF A PACKAGED APPLICATION INCLUDING SELECTION OF USER-INTERFACE ELEMENTS - The present disclosure relates to methods and apparatuses for forming a packaged application based on a selected subset of user-interface elements. One example method includes receiving a selection of a subset of user-interface elements of a packaged application at a device, determining data of the packaged application associated with execution of the subset of user-interface elements, and packaging the data to form another packaged application for executing the subset of user-interface elements. | 05-05-2016 |
| 20160124745 | REFINING COMPOSITION INSTRUMENTATION FOR SERVICES - In an approach for creating a service composition, a processor receives a plurality of software modules, wherein each software module performs part of a service requested by one or more users on a network. A processor collects one or more attributes and one or more dependencies for each of the plurality of software modules. A processor appends information about the attributes and the dependencies to each respective software module. A processor stores each of the plurality of software modules with the respective appended information in a database. A processor creates a service composition comprised of a combination of the plurality of software modules, based on the appended information and the service requested by the one or more users on the network. | 05-05-2016 |
| 20160132328 | Configuration Packages for Software Products - A configuration package receives user-generated input that configures a decision service to generate decision data. The configuration package includes artifacts and the user-generated input selects the artifacts from an artifact library in a configuration database. A configured decision service is generated, where the generating includes receiving, by a decision service factory, the configuration package. Also, the decision service factory receives a decision template including configurable decision elements and non-configurable decision elements. Further, the decision service factory receives a user configuration specifying a parameter in the corresponding artifact. The artifact from the configuration package, the user configuration and the decision template are combined to generate the configured decision service. The configured decision service receives, from a client computer, input for each of the configurable decision elements. Based on the received input, the decision data is generated by the configured decision service. The generated decision data is transmitted to the client computer. | 05-12-2016 |
| 20160139914 | CONTEXTUAL-BASED LOCALIZATION BASED ON MANUAL TESTING - Example embodiments relate to contextual-based localization based on manual testing. A system may recreate, based on code of an application and user action data, how a user interacts with the application. The user action data may indicate how the user interacts with the application while manually testing the application. The system may detect screen states in the code based on the recreation. The screen states may be associated with screens displayed to the user while the user interacts with the application. The system may create, for each of the screen states, a translation package that includes a screen shot related to the particular screen state and a reduced properties file that includes a portion of a properties file that is related to a portion of the code that is associated with the particular screen state. The properties file may include information that can be used to localize the code. | 05-19-2016 |
| 20160139917 | INCREMENTAL SOURCE CODE ANALYSIS - Methods, systems, and apparatus, including computer programs encoded on computer storage media, for generating a full set of analysis artifacts after incremental analysis of a source code base. One of the methods includes receiving a first full set of analysis artifacts and an incremental set of analysis artifacts for a project. An initial keep graph that is initially equivalent to the full build graph is generated. Any source code file or analysis artifact nodes that also occur in the incremental build graph are removed from the keep graph. Analysis artifacts for source code files in the full build graph that do not occur in the keep graph are deleted from the first full set of analysis artifacts. The analysis artifacts represented by nodes in the incremental build graph are copied into the first full set of analysis artifacts to generate a second full set of analysis artifacts for the project. | 05-19-2016 |
| 20160154645 | METHOD AND SYSTEM FOR UTILIZING CHANGE PACKAGES | 06-02-2016 |
| 20160162305 | RUN-TIME ADAPTION OF EXTERNAL PROPERTIES CONTROLLING OPERATION OF APPLICATIONS - An aspect of the present disclosure provides run-time adaption of external properties controlling operation of applications. In one embodiment, a setup data is maintained indicating conditions and properties that control the operation of applications. Each property is associated with a corresponding condition in the setup data to indicate that the property is to be configured upon satisfaction of the corresponding condition. In response to determining that a specific condition indicated in the setup data has been satisfied, a set of properties that is associated with the determined condition is identified. The applications are then automatically configured to thereafter operate with the identified set of properties. | 06-09-2016 |
| 20160170712 | Method for integrally implementing development and release of APP | 06-16-2016 |
| 20160170741 | SYSTEM AND METHOD FOR CONTROLLING THE DEVELOPMENT OF A SOFTWARE APPLICATION | 06-16-2016 |
| 20160170747 | IMPACT PREDICTION OF SOFTWARE CHANGE DEPLOYMENT ON CUSTOMER SYSTEMS | 06-16-2016 |
| 20160179502 | IDENTIFYING SOURCE CODE USED TO BUILD EXECUTABLE FILES | 06-23-2016 |
| 20160179507 | ASSERTIONS BASED ON RECENTLY CHANGED CODE | 06-23-2016 |
| 20160179508 | ASSERTIONS BASED ON RECENTLY CHANGED CODE | 06-23-2016 |
| 20160179509 | CONTAINER BASED APPLICATION REIFICATION | 06-23-2016 |
| 20160179510 | PARALLEL DEVELOPMENT OF A SOFTWARE SYSTEM | 06-23-2016 |
| 20160188324 | CONFIGURATION OF APPLICATIONS TO DESIRED APPLICATION STATES - Some aspects of the disclosure provide a method comprising receiving, on a digital device, a selection of a first application state of a set of application states of an application, identifying and retrieving path instructions indicating a series of steps to navigate the application to the selected first application state of the set of application states, providing the path instructions to an accessibility module configured to provide accessibility services to a user of the digital device, and navigating, by the accessibility module, the application using the path instructions to configure the application to the selected first application state. | 06-30-2016 |
| 20160196137 | Smart Validated Code Searching System | 07-07-2016 |
| 20160202969 | AUTOMATIC SUBMISSION OF APPLICATIONS TO APPLICATIONS STORES | 07-14-2016 |
| 20160202972 | SYSTEM AND METHOD FOR CHECKING OPEN SOURCE USAGE | 07-14-2016 |
| 20160378463 | SELECTIVE NOTIFICATIONS ACCORDING TO MERGE DISTANCE FOR SOFTWARE VERSION BRANCHES WITHIN A SOFTWARE CONFIGURATION MANAGEMENT SYSTEM - A computer-implemented method of controlling version branching within a software configuration management system (SCMS) can include, responsive to a user initiating a check-out operation of a file within the SCMS, identifying the file and a workspace of the user and searching nodes of the repositories of the SCMS for a successor version of the file. When a successor version of the file is located within a node that is within a predetermined distance of the workspace of the user, a notification that the successor version of the file is within the predetermined distance of the workspace of the user can be output. When a successor version of the file is not located within a node within a predetermined distance of the workspace of the user, the file can be checked-out to the workspace of the user. | 12-29-2016 |
| 20190146772 | MANAGING UPDATES TO CONTAINER IMAGES | 05-16-2019 |
| 20190146782 | CONFIGURATION GUIDE EDITOR TO GENERATE INTERACTIVE CONFIGURATION GUIDES AND AUTOMATION CONTENT | 05-16-2019 |
| 20190146783 | COLLABORATIVE SOFTWARE DEVELOPMENT WITH HETEROGENEOUS DEVELOPMENT TOOLS | 05-16-2019 |
