Entries |
Document | Title | Date |
20080201694 | CODE RECOVERY SYSTEM AND METHOD - A system and method for restoring a computing system to a first operating state associated with a first system software code installed on the computing system is provided. The method comprises installing a second system software code on the computing system, while the system is operating in the first operating state. The second system software code is activated and the first system software code is deactivated to cause the computing system to operate in a second operating state. The first system software code is activated and the second system software code is deactivated to cause the system to return to the first operating state, if activation of the second system software code causes the system to operate in an undesirable manner. | 08-21-2008 |
20080209396 | Homepage for Modular Software - A multi-module application has a main module that generates a homepage user interface in a window for accessing a number of function modules of the application. Upon startup of the application, the main module parses a startup xml file that stores information about the function modules and generates the homepage user interface. When a user selects a function provided by a function module, the main module runs the function module and switches from the homepage user interface to a user interface of the function module in the same window. The user may return to the homepage from the function module by selecting a homepage button in the user interface of the function module. When a function module is added or removed from the application, an installer or uninstaller program updates the startup xml file by adding or removing information about the function module. | 08-28-2008 |
20080209397 | METHOD AND APPARATUS FOR ON-DEMAND COMPOSITION AND TEARDOWN OF SERVICE INFRASTRUCTURE - A computer implemented method, apparatus, and computer usable program code for creating a composite service. Dependencies are identified utilizing a set of active objects used to manage services to form identified dependencies in response to receiving a request for the composite service. The identified dependencies specify requirements of the composite service. The composite service has multiple components. Components are identified for the composite service using the identified dependencies to form identified components. The composite service is created using the identified components. | 08-28-2008 |
20080222603 | Addressing managed elements in a common information model environment - Systems and methods disclosed herein are operable to receive a command line; parse the command line; and map tokens in the command line to a target entity that corresponds to a Common Information Model (CIM) name. The target entity is an instance of a managed element. | 09-11-2008 |
20080222604 | METHODS AND APPARATUS FOR LIFE-CYCLE MANAGEMENT - The invention provides in some aspects a digital data processor executing management software that controls overall operation of the device, including, installation, configuration, updating, and/or other modifications of its software, hardware and configuration files and other “assets.” The management software validates changes to those assets (e.g., software updates and configuration file edits) requested by system administrators and others and can propagate related changes to other assets. As a result, it keeps the digital data processor in a consistent, working state, avoiding operational interruption that might otherwise result from corruption of assets (e.g., lost files) and/or attempts to install inconsistent assets. The management software can serve as an agent for one or more external digital data processing devices that are in communications coupling with the managed digital data processing device, which one or more external digital data processing devices mediate installation, configuration, updating, modification and/or use of the one or more assets. | 09-11-2008 |
20080222605 | Program Maintenance Support Device and Program for the Same - The present invention includes program storing unit | 09-11-2008 |
20080229281 | METHOD FOR DATA EXCHANGE BETWEEN MEDICAL APPARATUSES - In a method, a device and a system as well as a modality and a computer program product for integration of a data object into a medical data set, the data object and the medical data set are associated with a patient examination. The medical data set is formatted according to a DICOM standard. The data object is formatted according to a standard other than the DICOM standard. The data object is integrated into the medical data set via at least one shadow group object and a running and/or planned process in connection with the patient examination can be controlled dependent on the integrated data object. | 09-18-2008 |
20080235663 | Change Management for Structure Objects - A structure object is locked to prevent changes to the structure object in previous phases of a software life cycle. When a request to change the structure object in a previous phase is received, a change request file is opened. The changed request is approved or denied based at least in part on the previous phase. If the changes request is approved, a document is generated for the change request. Any changes made to the structure object are integrated into the previous phase of the structure object and are also stored in the document. If the change request is denied, the change request file is closed. | 09-25-2008 |
20080235664 | METHOD, SYSTEM AND COMPUTER PROGRAM FOR DISCOVERING MULTI-COMPONENT SOFTWARE PRODUCTS - A solution ( | 09-25-2008 |
20080235665 | System and method for automated safe reprogramming of software radios - The proposed system defines an automated safe reprogramming of software radios. The essence of software radios is to enhance or alter the functionality of a mobile terminal by using software. This means that the required software is downloaded onto a mobile terminal on the fly to meet the critical and necessary needs of the user. Lot of caution needs to be exercised while downloading the necessary software components on the fly. The proposed invention automates the validation and verification of the downloaded component by suggesting (a) a variety of signatures; (b) a means for defining multiple zones and verification of zone-specific signatures; (c) a means for computing the signatures of the downloaded component in the multiple zones; and (d) a means for verification of the downloaded component based on the signatures. The objective is to define the safeness of the downloaded component based on multiple signatures to be validated in different zones. In this way, the multiple validity requirements are tested in a systematic way and failure to meet any one of the requirements leads to the rejection of the downloaded component. | 09-25-2008 |
20080244517 | HORIZONTAL AND VERTICAL FILTERING OF MULTI-DOMAIN BUSINESS APPLICATION MODELS - This disclosure relates to methods, systems, and software for horizontal and vertical filtering of business application models. Such software may identify a first modeling domain and a second modeling domain for a business application. The software can then apply a filter to at least the first modeling domain to determine a subset of the first and second modeling domains and present the subset of one of the modeling domains to a client. In some situations, each modeling domain may be a UI domain, a business process domain, or a data domain. Further, the first modeling domain can represent the particular domain in a first logical layer and the second modeling domain can represent the same domain in a second logical layer. Moreover, the software can apply any suitable number of filters, whether vertical and/or horizontal, to any number of appropriate domains and layers. | 10-02-2008 |
20080244518 | Telecom Business-Oriented Taxonomy for Reusable Services - A method, system, and computer program product for a management and development framework of shared business service assets within a common services oriented architecture strategy are provided. The framework comprises a multi-dimensional business oriented taxonomy that is aligned with organizational business services requiring software support. The framework affords advantageous placement of business service assets using a product publication schema and rapid search and discovery of business service assets through a product discovery schema. Implementation of the framework across multiple units of an organization facilitates business service asset reuse, thereby enabling a minimization of asset redundancy, reduction in business application development time and cost, and rapid market entry for organizational products. | 10-02-2008 |
20080244519 | Identifying, Correcting and Displaying Application Website and Device Compatibility Issues - A method of identifying, correcting and displaying application website and device compatibility issues is disclosed. An agent framework is started that host compatibility agents. The compatibility agents are used to analyze an operating system user such as a device, an application or an update. The results of the compatibility agents are communicated to a database and the results of the compatibility agents are displayed using a user interface. | 10-02-2008 |
20080250392 | CONTENT MANAGEMENT SYSTEM FOR COMPUTER SOFTWARE WITH DYNAMIC TRACEABILITY BETWEEN CODE AND DESIGN DOCUMENTS - A content management system (CMS) for computer software provides automatic notification and correlation of changes in a design document with corresponding code, and provides automatic notification and correlation of changes in the code with one or more corresponding design documents. Traceability rules are defined that correlate which portions of the code correspond to which portions of the design document. A traceability update policy governs whether interested parties are notified of a change to either the design document or the corresponding code, and whether the change to one causes an automatic update to the other. The result is a content management system that helps keep the code and corresponding design documents consistent with each other so the system has accurate and consistent information at all times. | 10-09-2008 |
20080250393 | Service assembly architecture - A multi-user communications service is configured by: setting up a choreography linking a plurality of user process control flows and a multi-user service configuration process; receiving via the choreography at the multi-user service configuration process requests from the plurality of user process control flows for access to the multi-user communications service and granting access to the multi-user communications service to selected users; in which the choreography provides a fixed interface supporting the independent reconfiguration of the user process control flows and the multi-user service configuration process. | 10-09-2008 |
20080256514 | Side-by-side application manifests for single-purpose applications - Architecture that adds logic to a client hosting application to process a single-purpose application (SPA) prepared and received as an isolated application. The SPA (e.g., a gadget), as an isolated application, provides one or more manifest files that allow an SPA author to deploy private binary code (e.g., a private ActiveX control) as another file in the SPA distribution, and not exposing the binary code for use by another client application or other programs on the user computer. Thus, only the SPA that came with the binary code will have access to that code. | 10-16-2008 |
20080256515 | Systems & Methods For Creating Software - Software generates interfaces and functionality for an application program. At least a portion of an application is created by given names to data elements according to a syntax. Data tables are generated having fields that correspond to the elements and characteristics are associated with the fields specifying how the data in the fields interact with each other. Relationships among the elements are inferred as a function of their names. A functional interface can be generated from the inferred relationship. | 10-16-2008 |
20080263518 | SOFTWARE DOCUMENTATION MANAGER - A computer-implementable method and system for managing software code documentation is disclosed. The method receives computer software code and documentation selected by a user and inserts one or more association keys in the selected code and one or more association keys in the selected documentation. The association keys are used to identify a portion of computer software documentation that corresponds with the computer software code. When the user wants to see documentation for a section of code, or code that corresponds to a section of documentation, the user selects the relevant text. The method receives the selected text, retrieves the association keys inserted in the selected text, determines whether the selected text is code or documentation, searches for documentation or code with matching association keys and alters the display of the matching documentation or code. | 10-23-2008 |
20080270985 | DATABASE APPLICATION ASSEMBLY AND PREPARATION - A plurality of database application components available in a first components store is received. A plurality of pointers is created with each of the plurality of pointers referencing a selected object, such as the plurality of database application components or an existing pointer to one of the plurality of database application components. The plurality of pointers is collected into a reference group defining a plurality of selected objects included in a database application. In some examples, the database application components include a header, a footer, a control, a fragment, a table, a query, a report, a relation, a form, a conditional formatting statement, a programming component, a validation statement and a module. | 10-30-2008 |
20080270986 | SYSTEM AND METHOD FOR ENTERPRISE JAVABEANS CONTAINER - A system to implement functionality for running Enterprise JavaBeans. The functionality is provided by a set of components. The components include a life cycle manager, a client views manager, a proxy invocation handler, an invocation chain manager, and an invocation context. | 10-30-2008 |
20080276221 | METHOD AND APPARATUS FOR RELATIONS PLANNING AND VALIDATION - A method and apparatus for validating at least one rule in a system containing objects related by relationships. The objects can be software components and the relationships can be a containing relationship or a dependency relationship. The input and output of the system can be of pre-defined or user-specific formats, and the validated rules can also be out of the box, or user-supplied. The apparatus generates an internal model upon which the rules are validated. The method and apparatus can be used for testing software, for instance. | 11-06-2008 |
20080288921 | Transformations for Software Obfuscation and Individualization - Methods and systems for software obfuscation are disclosed. In one exemplary embodiment, the obfuscation includes integrating the checker code with product code to form integrated code. The product code includes a first portion that provides desired functionalities to a software product, while the checker code includes a second portion that protects the product code from unlicensed use. A generated pseudorandom value is used to select one or more instruction sequences of the integrated code. Following the selection, the instruction sequences may be replaced with equivalent instruction sequences to form a new integrated code. Alternatively, the original integrated code is transformed into new integrated code when the selected instruction sequences are optimized. Additionally, the new integrated code may be compared to the original integrated code by generating output states from each integrated code. The new integrated code is functionally equivalent to the original integrated code if the respective output states match. | 11-20-2008 |
20080295074 | Data management interface with configurable plugins - A method and apparatus for managing data. A data management interface that delegates data operations to one or more plugins is configured, each plugin being associated with a distinct data operation. A new plugin is identified. The data management interface is reconfigured to enable the new plugin, the reconfiguring being transparent to at least one application requesting a data operation. | 11-27-2008 |
20080295075 | INTEGRATED SOFTWARE DEVELOPMENT SYSTEM, METHOD FOR VALIDATION, COMPUTER ARRANGEMENT AND COMPUTER PROGRAM PRODUCT - An integrated software development system including an interface description language adapted to specify constraints on input parameters, a program analyzer adapted to identify input parameters of a software program, and a validation enforcement system adapted to enforce that an interface description in the interface description language complying with a predefined set of validation rules is provided for the input parameters of the software program. | 11-27-2008 |
20080301637 | Profile service based deployment configuration - A method and apparatus for providing a profile service in an application server for deployment configuration. In one embodiment, the method of the profile service includes populating a repository with deployments of an application server. The method of the profile service further includes managing the lifecycles of the deployments, and determining objects to instantiate when the deployments start. | 12-04-2008 |
20080301638 | Method and Apparatus for a System Management Tool to Adapt Command Interface and Behavior Based on Installed Features - A system management tool framework for a system management tool for extending system management commands related to software installation units such as software component, feature or product. The tool is constructed in accordance with an interface and framework that allows polymorphism and dynamic binding at run-time. When the system management software tool is constructed in accordance to the framework of the present invention, the software tool can be made scalable, flexible and adaptable to a heterogeneous distributed system. | 12-04-2008 |
20080301639 | Identifying Changes in Source Code - A data processing method comprises maintaining a source code repository, checking out a component from the source code repository, checking in a modified version of the component to the source code repository, identifying the changes between the modified version of the component and the original component, applying one or more pattern matching techniques to the identified changes, storing the output of the pattern matching techniques, and displaying the output. | 12-04-2008 |
20080301640 | METHOD AND SYSTEM FOR ALLOCATING ID OF SOFTWARE COMPONENT - A method for allocating an identifier (ID) of a software component is disclosed. The method includes generating information on software components by a Device Management (DM) server, generating a download package including the information on software components by the DM server, transmitting the download package from the DM server to a DM client, executing the download package by the DM client, and allocating an ID to each software component based on the information on software components if the download package is executed by the DM client. | 12-04-2008 |
20080307392 | System architecture for business process development and execution - A system for designing a business process includes an introspection module that transforms implementation-specific components into generic components. The implementation-specific components are associated with a number of implementations. A component manager defines the generic components. A process designer selects at least one of the generic components from the component manager, and generates a business process that uses the at least one of the generic components. | 12-11-2008 |
20080307393 | SYNCHRONIZING CODES FROM MULTIPLE SOFTWARE CONFIGURATION MANAGEMENT SYSTEMS - The invention is directed to synchronizing code from multiple Software Configuration Management (SCM) systems. A method according to an embodiment of the invention includes: obtaining source code from a foreign SCM system and a central SCM system; obtaining a list of files and directories from the foreign SCM system and the central SCM system; creating a batch file; iteratively verifying from the list of files and directories from the foreign SCM system source code whether each file is one of: a new directory, an existing directory, a new file, or an existing file; for each new file and new directory verified from the foreign SCM system, creating in the batch file a command to add the new directory or the new file to the central SCM system; and completing the batch file. Another embodiment includes merging files in the central SCM system. | 12-11-2008 |
20080307394 | Asynchronous load of source dependencies - Asynchronous loading of source dependencies is disclosed. An indication is received in the course of executing a script that a source file on which a current class or function depends is not available. Execution of remaining portions of the script, if any, that do not depend on the source file, continues, or other processing tasks are performed if no such portions remain, while the source file is loaded asynchronously. | 12-11-2008 |
20080313614 | EMBEDDED CONTROLLERS AND DEVELOPMENT TOOL FOR EMBEDDED CONTROLLERS - An embedded controller development tool which generates an interface means for preserving and outputting a control data calculated by the control operation means based on a specific computational procedure, and providing said control data to a plurality of control operation means including said control operation means; wherein the control operation means is described as a function in the source code of the program, the reference data used for calculation by said control operation is an argument of the function, said control data calculated by said control operation means is the argument of the function which points the return value or the address of said function. | 12-18-2008 |
20090007068 | Accessing Non-Public Code - Non-public software constructs within a portion of code may be made accessible by analyzing the code, locating non-public items such as classes, objects, data structures, methods, interfaces, arrays, and other items, and creating a public call for the item in an executable code. In some instances, a call may reference one or more non-public items and such a call may be a static call created at the same time as the function, or may be a dynamically created at runtime. The calls may handle non-public arrays within calls, generic calls, as well as calls using a non-public interface. | 01-01-2009 |
20090007069 | Integrating loosely coupled tools using contracts and references - Various technologies and techniques are disclosed for providing an integration framework that enables tools to be integrated. The integration framework enables tools participating in the framework to be encapsulated in a manner that hides their implementations, thereby preventing them from taking deep dependencies on each other. The integration framework also enables the tools participating in the framework to carry formal type definitions called service and data contracts that describe the public behaviors they offer. The integration framework also provides support for migrating integration logic from tools into pluggable commands to further reduce coupling between the tools. | 01-01-2009 |
20090007070 | Efficient retry for transactional memory - Various technologies and techniques are disclosed for implementing retrying transactions in a transactional memory system. The system allows a transaction to execute a retry operation. The system registers for waits on every read in a read set of the retrying transaction. The retrying transaction waits for notification that something in the read set has changed. A transaction knows if notification is required in one of two ways. If the transactional memory word contained a waiters bit during write lock acquisition, then during release the transactional memory word is looked up in an object waiters map, and waiting transactions are signaled. If a writing transaction finds a global count of waiting transactions to be greater than zero after releasing write locks, a transaction waiters map is used to determine which waiting transactions need to be signaled. In each case, the write lock is released using a normal store operation. | 01-01-2009 |
20090013309 | Generation of Custom Software Applications - A system for generating a custom software application is disclosed. The system includes an interface module programmed to generate an interface and configured to receive input. The system further includes a data generation module programmed to generate data defining operation of a custom software application in response to the input received through the interface. The system further includes an engine module programmed to generate the custom software application in response to the data generated by the data generation module. A method for generating a custom software application is also disclosed. | 01-08-2009 |
20090013310 | SYSTEM AND METHOD FOR DEVELOPING RICH INTERNET APPLICATIONS FOR REMOTE COMPUTING DEVICES - A system for developing rich internet applications (RIAs) for remote computing devices that utilize a certifying player to invoke server-side web services through a single, secure, certifying intermediary server, includes an integrated development environment (IDE). The IDE includes a toolbox comprising graphical components configured to be dragged and dropped into UI states implementing the RIA process flow and a Web Service Description Language (WSDL) integrator for generating web service call for accessing web services for processing input from the UI states and generating an output result. | 01-08-2009 |
20090019425 | DATA SPLITTING FOR RECURSIVE DATA STRUCTURES - Embodiments of the present invention provide a method, system and computer program product for the data splitting of recursive data structures. In one embodiment of the invention, a method for data splitting recursive data structures can be provided. The method can include identifying data objects of a recursive data structure type, such as a linked list, within source code, the recursive data structure type defining multiple different data fields. The method further can include grouping the data objects into some memory pool units, each of which can contain the same number of data objects. Each memory pool unit can be seen as an array of data objects. The method can include data splitting, which could be maximal array splitting in each different memory pool unit. Finally, the method can include three different approaches, including field padding, field padding and field splitting, to handle irregular field sizes in the data structure. | 01-15-2009 |
20090031286 | DEVICE-BASED SOFTWARE AUTHORIZATIONS FOR SOFTWARE ASSET MANAGEMENT - Software device groups allow owners and administrators to be defined for various intelligent devices, instead of tracking by primary user. A software license compliance management system obtains discovery information for these devices to determine software installed or active on these devices. The management system also obtains the number of licenses for each software package and determines whether the software is in compliance, or if the number of instances exceeds the number of licenses. This determination is flexible and can handle various license types, such as per user, per device, and per processor. For any exception, the group owner is informed and then can re-allocate licenses, purchase additional licenses, or request the uninstalling of a software instance(s). Device groups also can include sub-groups with sub-group owners responsible for handling any exception in that sub-group. | 01-29-2009 |
20090031287 | CONTAINER-LESS JSP TEMPLATE - A container-less JSP system is provided. An example container-less JSP system comprises a detector, a trigger module, and an invoker. The detector may be configured to detect a request initiated by a client application to invoke a JSP template. The request is a protocol-neutral Java™ interface. The trigger module may be configured to trigger the protocol-neutral Java™ interface to invoke the JSP template. The invoker may be configured to invoke the JSP template. | 01-29-2009 |
20090037878 | Web Application Development Tool - Method, system and computer program product are provided to increase the efficiency of the development of Java Enterprise Edition (J2EE) applications. A project may be divided into modules which may be developed by independent teams. The files within each module are classified as independent of resources in other modules or dependent. Independent files may be packaged into a single, integrated web application archive (WAR) file without further processing. Corresponding dependent files are compared and any conflicts are resolved. The resulting files may then be packaged into the WAR file. | 02-05-2009 |
20090049426 | Reusing an application object - The present invention provides methods, apparatus and systems for reusing an application object for use with an application program, in which the object can be reused without causing nonconformity in the consistency or security, even if the object to be reused is updated. An example of a method includes detecting that the application program ends referring to the application object, detecting that the application object is updated by the application program, deciding to reuse the application object in response to detecting no update of the application object, making the application object reusable in response to the end of referring to the object, and decision to reuse the application object. | 02-19-2009 |
20090064106 | Reusing Components in a Running Application - Methods, systems, and apparatus, including computer program products, for reusing a component. In one aspect, a method includes executing a source application in an application environment; presenting a reusable component in a source application window corresponding to the source application, wherein the reusable component is visibly distinguishable from one or more non-reusable components displayed in the source application window; receiving input selecting the reusable component in the source application window and adding the reusable component to a target application window corresponding to a target application; and inserting one or more computer-readable instructions associated with the reusable component into the target application. Further, input can be received to activate a reuse function associated with the source application. Additionally, the reusable component can be visibly distinguishable from one or more non-reusable components displayed in the source application window only when the reuse function is active. | 03-05-2009 |
20090064107 | Token Transformation Profiles and Identity Service Mediation Node for Dynamic Identity Token - A method comprising, sending a request from a requester to a provider via a bus, the request including a provider description and an identity token of a first type, wherein the bus includes an identity service mediation node having data associating a plurality of providers descriptions with corresponding identity token types, determining with the identity service node an identity token type associated with the provider description, updating the request with data including the identity token type associated with the provider description, sending the updated request with data including the identity token type associated with the provider description to an identity service via the bus, transforming the identity token of the first type into an identity token of the type associated with the provider description with the identity service, and sending the request including the transformed identity token to the provider via the bus. | 03-05-2009 |
20090083709 | UNIFIED MESSAGING STATE MACHINE - A unified messaging (UM) application benefits from platform independence and human intelligibility of eXtended Markup Language (XML). A finite state machine (FSM) of the UM application is created utilizing an XML feature to create a valid menu state based upon a UM software component. For a UM software component that is a context or setting of the UM application, an XML conditional attribute conditions a prompt, transition or grammar node of the UM FSM. For a UM software component that is an XML snippet, an XML importation element replicates the XML snippet upon compilation, avoiding time-consuming and error prone requirements for manual code duplication. For a UM software component such as an external method, function, variable or action, a function wrapping XML tool validates the existence of such external UM software components at build time and captures version information to verify the availability of the same version upon execution. | 03-26-2009 |
20090083710 | SYSTEMS AND METHODS FOR CREATING, COLLABORATING, AND PRESENTING SOFTWARE DEMONSTRATIONS, AND METHODS OF MARKETING OF THE SAME - A software demonstration may be created by capturing screenshots of normal use of an application. The authoring tool may capture a screenshot upon detecting an input. Before capturing the screenshot, the authoring tool may delay for a pre-determined and/or user-configurable period of time to allow the computer display to be refreshed. The authoring tool may provide a cue to inform the user of the timing of the screenshot acquisition. If a screenshot is mistimed, it may be replaced without interrupting the flow of the software demonstration. Screenshots may be linked to one another using clickable hotspots. The hotspots may be used in presenting the software demonstration to provide for a realistic presentation of a software product. The authoring tool may publish the software demonstration in a web accessible format to a network accessible storage location to allow reviewers to comment on the demonstration. An author may access the presentation to review commentary on the demonstration. A software demonstration may be published as a distributable file which may comprise the software demonstration, a player to allow a recipient to view the demonstration, and a version of the software demonstration tool to virally create marketing opportunities for the authoring tool. | 03-26-2009 |
20090089751 | EXPOSING FEATURES OF SOFTWARE PRODUCTS - The claimed subject matter provides a system and/or a method that facilitates exposing a software feature to increase productivity of performing a task. A software component can include a plurality of software features in which the software component can rank and assign a skill level to an entity utilizing at least one software feature. A smart help component can supply the entity with an informative tip based on the skill level rank, wherein the informative tip can assist in utilizing at least one software feature. | 04-02-2009 |
20090089752 | System and Method for Generating an Application Fragment - Methods, systems, and apparatus, including computer program products, for storing an application fragment. In one aspect, a method includes presenting a component in a donor application window corresponding to a donor application, wherein the donor application is executing in a computing system; receiving input selecting the component in the donor application window for insertion into a file system associated with the computing system; generating an application fragment corresponding to the component; and storing the application fragment in the file system. Further, the method can include inserting the application fragment into a recipient application window associated with a recipient application and activating functionality of the recipient application based on the application fragment. Additionally, the application fragment can be activated in the file system and an application including at least a component based on the application fragment can be generated in response to the activating. | 04-02-2009 |
20090113389 | Interactive multimedia applications device - An interactive multimedia applications device and method for an interactive multimedia application comprises one or more live media capture devices providing a media stream, an engine comprising a real time media processing module for processing said media stream, and rendering means connected to multimedia output devices. In addition, said device comprises (i) a virtual scenario description repository adapted for storing a plurality of scenarios expressed in a scenario programming language; (ii) a memory module adapted for storing an internal representation of one of said scenarios, and an internal representation of a virtual scene and (iii) a parser/loader for parsing a selected one of said plurality of scenarios, and loading it in said memory module. | 04-30-2009 |
20090113390 | MODULE-CODE VERIFICATION LAYER TO AUTOMATICALLY VALIDATE USER INPUT - Methods and systems for verifying module codes are presented. The module code may be verified by associating the module code with a user interface screen and determining whether the module code was generated from the user interface screen. A module corresponding to the module code may be executed if the module code is verified. The module code may be verified by using routines from a user interface framework system. The module code may be verified by determining whether a user interface element associated with the module code is disabled. The module code may be verified by determining whether each user interface element associated with the module code is enabled. The module code may be verified by insuring that the module code was generated by the selection of a user interface element. The module codes may be received from a front-end system and verified on a back-end system. | 04-30-2009 |
20090113391 | Software License Isolation Layer - A software development environment for developing application software for a target computing platform, having target platform licensed software components subject to target platform license terms, the development environment isolates source platform application source code for the application software from being subjected to the target platform software license terms while allowing the application source code to indirectly refer to the target platform licensed software components having the target platform license terms. A license isolation layer may include an interface definition and an implementation of the interface definition. The application source code binds to the implementation of the license isolation layer interface definition. The software development environment includes a compiler that compiles the application source code such that it is isolated from applicability of the target platform license. | 04-30-2009 |
20090125884 | SYSTEM AND METHOD FOR WORKFLOW-DRIVEN DATA STORAGE - Programs, systems and methods are described for efficiently storing data as used under a workflow-driven model. A workflow process is defined to control the processing of data objects through different states, e.g., such as an insurance claim document passing through different stages of processing. The workflow process is modeled and employed to manage the storage system based upon predicted state changes derived from state statistics that can be applied to enhance efficiency. For example, copies of the data object may be automatically made when the data object is expected to change state. Some anticipated states implicating high access may direct a storage location with low access time. Hints or requirements for the data object may be applied upon occurrence of an expected state change. Storage management of expected state changes may be further enhanced through dynamic adjustment of the state statistics using collected historical state information to further enhance efficiency. | 05-14-2009 |
20090125885 | Method and system for whitelisting software components - A method and system for whitelisting software components is disclosed. In a first operating environment, runtime information may be collected about a first loaded and executing software component. The collected information may be communicated to a second software component operating in a second operating environment that is isolated from the first operating environment. The collect runtime information may be compared with a validated set of information about the first software component. Other embodiments are described and claimed. | 05-14-2009 |
20090144698 | PRIORITIZING QUALITY IMPROVEMENTS TO SOURCE CODE - An exemplary method includes receiving source code having a plurality of code segments, providing a desired level of quality for the source code, analyzing the source code to assign a complexity measure to each of the plurality of code segments and assigning a level of code coverage to each of the plurality of code segments based at least in part on the desired level of quality and the complexity measures. An exemplary system prioritizes quality improvements to source code based, in part, on a quality assessment. Such a system can improve code quality by assigning higher test coverage levels to modules with higher complexity. | 06-04-2009 |
20090144699 | LOG FILE ANALYSIS AND EVALUATION TOOL - A method is provided for automatically evaluating a log file of a software module. Prior to an execution of a first version of a software module, the method comprises evaluating all possible messages or events that can occur in a log file of the first version of the software module, and establishing the messages or events as evaluation criteria. Then, during execution of the first version of the software module, generating a log file comprising a plurality of message or events from the software module. Finally, after generation of the log file, the method comprises transferring the log file to an analysis system, automatically evaluating the plurality of messages or events in the transferred log file according to the previously established evaluation criteria, thereby creating relevant developer error information, automatically informing developers about the relevant developer error information. This information is used to further improve the software. | 06-04-2009 |
20090150865 | Method and system for activating features and functions of a consolidated software application - A system and method for activating selected features and functions of a software application during installation of software. | 06-11-2009 |
20090150866 | Enforcing legal holds of heterogeneous objects for litigation - Software for managing legal holds on objects identifies a target object to associate with a particular legal hold. The example software is further operable to automatically communicate with a lookup table to verify a hold record associated with the target object. In another example, the software for managing legal holds on objects can receive a legal hold status request for a target object associated with a business application. The software can automatically communicate with a lookup table to determine a hold record identifying a legal hold associated with the target object. The software is further operable to respond to the legal hold status request with a legal hold status based on the lookup table communication. | 06-11-2009 |
20090158253 | METHOD AND SYSTEM FOR AUTOMATICALLY IDENTIFYING THE SOURCE OF COPIED SOFTWARE - A method, system, and computer-usable medium for automatically identifying the source of copied software. A single identifying marker can be embedded in a common code base associated with different software application products. A suspected copy of a product can be fed to an automated tool, which extracts the type of object code, which is then scanned to determine the identifying marker. The automated tool can therefore identify the exact product and version of the suspected copy utilizing the identifying marker and the type of object code without the need for labor-intensive modification of the common code base and product-specific markers. | 06-18-2009 |
20090172639 | FIRMWARE INTEGRITY VERIFICATION - In some embodiments, the integrity of firmware stored in a non-volatile memory is verified prior to initiation of a firmware reset vector. Other embodiments are described and claimed. | 07-02-2009 |
20090178026 | SELF-DESCRIBING RE-USABLE SOFTWARE COMPONENTS - Technologies are presented herein for self-describing re-usable software components. Metadata is generated and published with a re-usable software component that identifies the capabilities of the software component, identifies other software components that the re-usable software component may be integrated with, and identifies mechanisms for integrating the re-usable software component with other software components. The metadata can then be used to discover re-usable software components and to integrate the re-usable software components with other software components. | 07-09-2009 |
20090178027 | LAYERED ARCHITECTURE FOR MOBILE TERMINALS - Software architecture for a mobile terminal for a wireless telecommunications system and for other applications. The software architecture includes a plurality of layers arranged in order from layers providing higher level services to layers providing lower level services, at least one software module in each layer, and interface means for permitting communication among software modules pursuant to a set of defined dependency rules. | 07-09-2009 |
20090187887 | BLOCK COUNT BASED PROCEDURE LAYOUT AND SPLITTING - The present invention extends to methods, systems, and computer program products for block count based procedure layout and splitting. Embodiments of the invention utilize code block counts to provide a total ordering of code blocks that improves execution time of generated procedure code by minimizing branches along more frequently executed paths. The total ordering is optimized using prioritized precedence relationships. For example, the total ordering is optimized to maximize the appropriate placement of code block chains after other code block chains. The total ordering is also optimized to place zero count (untouched) code blocks after any non-zero (touched) code blocks. | 07-23-2009 |
20090187888 | METHOD FOR SINGLETON PROCESS CONTROL - A method for singleton process control in a computer environment is provided. A process identification (PID) for a background process is stored in a first temporary file. The PID is stored by a parent process and subsequently accessed by the background process. The background process is exited if an active PID is determined to exist in a second, global temporary file. The PID from the first temporary file is stored into the second, global temporary file. A singleton code block is then executed. | 07-23-2009 |
20090193394 | Subsystem architecture for providing support services for software applications - A subsystem architecture is described that provides support services for software applications of a system. The subsystem architecture includes local infrastructure components, which provide infrastructure services to the software applications. Each local infrastructure component corresponds to a single software application and is independent from another of the local infrastructure components. The subsystem architecture may further include a central service component providing central services to at least one of the local infrastructure components. The central service component is independent and unaware of the local infrastructure components. Still further, the subsystem architecture may include an administrative component for monitoring and maintaining the local infrastructure components providing infrastructure services to the software applications. The administrative component is independent and unaware of the plurality of local infrastructure components. | 07-30-2009 |
20090210857 | AUTOMATED MERGING IN A SOFTWARE DEVELOPMENT ENVIRONMENT - A system and method for merging changed elements in a software development environment is provided, in which the software development environment is provided with a set of at least one defect, comprising at least one changed element, associated with a software project that comprises a plurality of elements, the software project comprising a plurality of elements. The environment first obtains a list of changed elements in a defect record, for example from a defect database, and for each changed element in the list, attempts an automated merge of the changed element with a corresponding target. If any attempt fails, the environment may re-attempt the merge for any failed attempt, and may invoke a user interface for resolving the merge manually. | 08-20-2009 |
20090217243 | AUTOMATIC SOFTWARE CONFIGURING SYSTEM - An automatic software configuring system includes a database storage section for storing therein a plurality of soft components. In the event that soft components are extracted from the database storage section and are combined together to thereby generate a file, a comment indicative of a storage location in the database storage section for storing a respective soft component extracted from the database storage section is added to the respective soft component. The automatic software configuring system further includes a device for identifying the respective soft component combined into the file and a storage location of the respective soft component in the database storage section by reading the comment; a device for identifying a comparison-target soft component stored in the database storage section for comparison with the respective soft component combined into the file in accordance with the storage location; a device for identifying a soft component having a different content by comparing the respective soft component combined into the file and the comparison-target soft component; and a device for replacing specified soft component in the database storage section with the soft component combined into the file. | 08-27-2009 |
20090249295 | SYSTEM FOR ESTIMATING A SOFTWARE PRODUCT RELEASE TIME FROM VERSION INFORMATION - Systems and processes for migration of data stored in a label-based software configuration management (CM) system to records of a time-based CM system in a manner that permits for identification, in the time-based system, of contents of releases. In some exemplary implementations, techniques operating according to some of the principles described herein will accept as input information relating to a listing of a label-based system and estimate, based on the software component versions in the listing and their corresponding creation times, a release time indicating a time a release was created. The release time may then be used, in some, but not necessarily all, implementations to create a data structure in the time-based system indicating contents of the version at the particular time. Some exemplary implementations may additionally determine, from the estimated release time, whether any software component versions should be explicitly included or excluded from the data structure. | 10-01-2009 |
20090249296 | INSTANTIATING A COMPOSITE APPLICATION FOR DIFFERENT TARGET PLATFORMS - A method, system, and computer program product for instantiating a composite application for different target platforms. In an exemplary manner, a template that describes a composite application having a plurality of application components is created. The template includes a composite application component assembly descriptor and a plurality of platform-specific handlers. The composite application component assembly descriptor lists each application component of the composite application. The platform-specific handlers handle the deployment of application components for the different target platforms. The composite application component assembly descriptor is evaluated to identify platform-specific implementations of the composite application components. The composite application is instantiated using one of the plurality of platform-specific handlers. The platform-specific handlers are included in the template for a platform-specific deployment for one of the plurality of target platforms. | 10-01-2009 |
20090254882 | METHODS AND DEVICES FOR ITERATIVE BINARY CODING AND DECODING OF XML TYPE DOCUMENTS - The invention concerns iterative binary coding/decoding for a document comprising values to code or to decode. For the coding, after having created ( | 10-08-2009 |
20090259990 | Mobile Device Software Management Method and Apparatus - Mobile device software is managed by providing an interface between a plurality of software module handlers and a plurality of software modules. The interface is invoked responsive to a software module event such as the installation, removal, activation or modification of a software module. The interface identifies the software module and a corresponding attribute list associated with the software module event. The attribute list specifies one or more actions to be taken by at least one of the software module handlers that enable the identified software module to provide one or more functions when invoked. The attribute list is provided to each software module handler identified in the list and each action specified in the list is taken by the corresponding software module handler. This way, the interface reliably manages the different software modules without being aware of the particular functions provided by the modules or the specific actions taken by the handlers. | 10-15-2009 |
20090265686 | SYSTEM AND METHOD FOR MANAGING RESOURCES USING A COMPOSITIONAL PROGRAMMING MODEL - A system and method for managing resources in a programming environment includes providing mutable entities including related data including triples, listening for changes in the related data, and triggering a first construct in accordance with the changes in the related data to update the mutable entities. Updates are propagated from the first construct to other constructs such that a cascade of updates occurs. The cascade of updates is executed concurrently such that the updates are propagated to completion and are executed all at once relative to other cascades of executing constructs. | 10-22-2009 |
20090276756 | Method To Apply Persistence To Selected Attributes Of Static And Dynamic Operating System Components - A process for managing customizations for components in a component tree includes for each customization associated with the parent of a component, matching the pathname of the component with the customization path. The process further includes associating the customization with the component, if the matching results in a partial match. The process further includes applying the customization to the component, if the matching results in a complete match. | 11-05-2009 |
20090282388 | OPTIMIZING THE HANDLING OF SOURCE CODE REQUESTS BETWEEN A SOFTWARE CONFIGURATION MANAGEMENT (SCM) SYSTEM AND A SOFTWARE INTEGRATED DEVELOPMENT ENVIRONMENT (IDE) USING PROJECTED ANCILLARY DATA - The present invention can include a solution for optimizing the handling of source code requests by a software configuration management (SCM) system by using projected ancillary data. When a SCM system receives a request for a source code file from a software integrated development environment (IDE), ancillary data can be projected for the requested source code file. Ancillary data can represent supplementary source code files and/or a revision update for an existing source code file. The projected ancillary data can be appended to a response message that already contains the requested source code file. The response message can then be sent to the software IDE. | 11-12-2009 |
20090300583 | Apparatus, Method, and Computer Program Product for Performing a Software Build - In accordance with an example embodiment of the present invention, an apparatus, comprising at least one receiver configured to receive a first software build information and at least one transmitter configured to send a computer program, wherein the computer program is based at least in part on the first software build information and a second software build information, is disclosed. | 12-03-2009 |
20090307661 | APPLICATION DEHYDRATION, SYNCHRONIZATION, AND REHYDRATION - Computer software applications may be separated into components and distilled into functional and identifying attributes, which may then be used to regenerate the computer software application on a different system. A component of a computer software program is received. From the component, one or more functional attributes describing the operation of the component on a first operating platform are distilled from which the component can be generated to operate on one or more operating platforms. Attributes identifying the component are identified. The functional attributes and the identifying attributes of the component are stored in a distillation store. From the distillation store, using information about a selected operating platform on which the computer software program is to be executed, components of the computer software program may be generated to execute on the selected operating platform. | 12-10-2009 |
20090307662 | SYSTEM AND METHOD OF IDENTIFYING AND TRACKING SOFTWARE PATTERN SOFTWARE RECIPES - A method and computer program product for identifying two or more software patterns within a software environment. At least one relationship between the two or more software patterns is identified. A software recipe is defined including the two or more software patterns and the at least one relationship. | 12-10-2009 |
20090313604 | PARSING OF DECLARATIONS IN ALL BRANCHES OF PREPROCESSOR CONDITIONALS - Declarations from an input source code or tokenized source code are serialized into a stream of tokens produced by following each branch of a preprocessor conditional directive statement that interrupts a declaration. Tokens are labeled with a parsing path indicator corresponding to a parsing path induced by branches of a preprocessor conditional directive. The declarations that are formed along the different parsing paths are serialized by fetching the tokens that belong to the first parsing path in a first pass, and passing the tokens on to a next phase of a compiler. The pointer that marks the next token is repositioned to return to the start of the declaration. The declaration may be serialized again through the second parsing path in a second pass. The operation may be repeated until each of the parsing paths induced by the presence of branches of the preprocessor conditional directives in the source code is exhausted. | 12-17-2009 |
20090319991 | Managed code type equivalence - The determination of whether two managed code types are of equivalent types on the basis of a comparison between type identifiers of the managed types. The type identifiers may be independent of an assembly in which the managed types are created, a namespace of the corresponding managed type, or a name of the corresponding managed type. Accordingly, the type equivalence determination may be made to be quite flexible, thereby potentially resulting in better type equivalence determinations in of managed types. | 12-24-2009 |
20090328001 | UNLOADABLE MANAGED CODE - The claimed subject matter provides a system and/or a method that facilitates generating unloadable managed code. A set of static subroutines included in a library or an assembly can be converted into dynamic subroutines created at runtime of an application. A reflection component can extract information regarding a static subroutine to produce a full description of structure and data of the subroutine. A dynamic method component can create a dynamic subroutine based upon the full description such that the dynamic subroutine provides substantially equivalent functionality to the static subroutine. In addition, resources allocated to the dynamic subroutine can be reclaimed to prevent waste and/or application bloat. | 12-31-2009 |
20090328002 | Analysis and Detection of Responsiveness Bugs - Described techniques increase runtime performance of software running in user space by analyzing and detecting soft hang program errors and giving suggestions for cures. This disclosure pertains to techniques for the analysis, detection, and cure of soft hang program errors. | 12-31-2009 |
20100005449 | METHOD AND APPARATUS FOR IMPROVING SECURITY IN AN APPLICATION LEVEL VIRTUAL MACHINE ENVIRONMENT - In one embodiment the present invention includes a security manager for managing security in a dynamic programming environment. The security manager interfaces between the dynamic programming environment and a non-dynamic programming environment. In this manner, the dynamic programming environment is unable to compromise the non-dynamic programming environment, yet still provide features desirable in a dynamic programming environment. An example using Ruby in a robust business programming environment is detailed. | 01-07-2010 |
20100011342 | SERVICE INTERFACE CREATION AND MODIFICATION FOR OBJECT-ORIENTED SERVICES - A method includes establishing a hierarchy of related software object classes according to a service, receiving data from an external process to invoke the service, and organizing the data received from the external process according to the hierarchy. A system includes a graphical user interface on a computing device configured to allow a user to organize a plurality of related software object classes into a hierarchy according to a service, and a service interface on a computing device configured to organize data received from an external service according to the hierarchy to allow the external process to invoke the service. | 01-14-2010 |
20100023926 | CALL GRAPH DEPENDENCY EXTRACTION BY STATIC SOURCE CODE ANALYSIS - A method of analyzing program source code prepared for a multithreading platform comprises analyzing a targeted source code set to extract a set of characteristic information for each wait operation; analyzing the targeted source code set to extract a set of characteristic information for each notification call to an application programming interface of the multithreading platform; identifying a one-way branching correspondence with a wait operation for each notification call by comparing the extracted set of characteristic information for the notification operation and the extracted set of characteristic information for each wait operation with a set of predefined asynchronous operation correspondence pattern information for notification and wait functions implemented by the application programming interface; extracting a set of information for each identified one-way branching correspondence; and storing the extracted set of information for each identified one-way branching correspondence in a data store. | 01-28-2010 |
20100023927 | APPARATUS AND METHOD FOR MIDLET SUITE MANAGEMENT USING DRM IN A MOBILE COMMUNICATION SYSTEM - An apparatus and method for MIDlet suite management using Digital Rights Management (DRM) in a mobile communication system are provided. A Java Application Descriptor (JAD) file transmission method of a transmit Mobile Station (MS) in a mobile communication system includes inserting a JAD file into an Open Mobile Alliance Digital Rights Management (OMA DRM) file, and transmitting the OMA DRM file in which the JAD file is inserted, to a receive MS. | 01-28-2010 |
20100031235 | Resource Double Lookup Framework - A system and method for localizing software having resource references and a resource library. A record of all resource calls performed by the software is generated. New resources are added to the resource library, and instructions are included, that map individual resource calls to resources in the resource library. | 02-04-2010 |
20100031236 | System and Method to Unify Multiple Service Environments to Optimize the Delivery of Telecommunications Services - System and method to unify multiple service environments to optimize the delivery of telecommunications services include a composite service execution environment providing a common platform for executing a plurality of different execution environments. A service creation environment enables creating of service logic from a plurality of pre-defined software components and one or more inter-method communication components operable to handle communications between the plurality of different execution environments. | 02-04-2010 |
20100042973 | METHOD FOR ANALYZING AN XACML POLICY - XACML (eXtensible Access Control Markup Language) documents, PolicySets and Policies can become long, complex and difficult to completely comprehend. A method is provided for facilitating analysis of such code to make it easier to answer questions such as: Given a particular set of Attribute values (and/or others unknown as of now), what is permitted or denied; are any of the rules redundant; are any of the rules inconsistent; for any pair of policies in the code, what set of Attributes will they both return Permit; how can a policy be refactored into an equivalent set of policies in which each branch of the policy tree pertains to specific values of specified Attributes? To facilitate such analysis and refactoring, every Rule in the collection of policies being analyzed is reduced to an equivalent expression in DNF (Disjunctive Normal Form). Some terms, predicates and other elements may be eliminated. | 02-18-2010 |
20100050155 | METHOD, COMPUTER PROGRAM PRODUCT, AND HARDWARE PRODUCT FOR PROVIDING PROGRAM INDIVIDUALITY ANALYSIS FOR SOURCE CODE PROGRAMS - A source code of a program is used to identify a first portion of the program that is predicted as being written by a first developer wherein a remaining portion of the program is written by a second developer. The program includes a plurality of program elements. Style information is extracted from each of the program elements. The style information is analyzed to identify a first set of program elements which have a first style corresponding to the first developer, wherein the first style differs from a second style corresponding to the second developer and used by a second set of program elements comprising remaining program elements of the plurality of program elements, and wherein the style information identifies a pattern indicative of how one or more non-syntactic characters have been inserted among syntactic program elements of the plurality of program elements. | 02-25-2010 |
20100064277 | Versioning And Refactoring Of Business Mashups In On-Demand Environments - Techniques are provided for versioning and refactoring of mashups. During the design phase of a mashup that is operable to access multiple external services, design information that defines or modifies a plurality of design elements included in the mashup is received from a user. Without receiving from the user any input that causes the plurality of design elements to be versioned, current versions of the plurality of design elements are automatically stored in a repository when the plurality of design elements are saved during development of the mashup. The mashup is deployed to one or more servers. Without receiving any input from the user that causes the mashup to be versioned, deploying the mashup comprises automatically storing in the repository a current version of the mashup and versioning information that associates the current version of the mashup with the current versions of the plurality of design elements. | 03-11-2010 |
20100064278 | PROGRAMMING SYSTEM AND PROGRAM EXPANDING METHOD - The invention provides a programming system comprising a software component, a client side, and N expanding module. The software component comprises a receiving/processing interface and N first link interface; the client side could be used for transferring client information to the software component through the receiving/processing interface; and each expanding module is corresponding to one of the first link interface and comprises an expanding content. Accordingly, a connecting relation could be built between the software component and one expanding module, corresponding to the client information, of the N expanding module through the first link module, so that the software component can communicate with the expanding module to obtain the expanding content. | 03-11-2010 |
20100077380 | FRAMEWORK FOR AUTOMATICALLY MERGING CUSTOMIZATIONS TO STRUCTURED CODE THAT HAS BEEN REFACTORED - A method of generating a tool for merging customizations made to a first version of a software artifact when migrating to a second version includes instantiating a mapping element for each top-level element in a first code set that does not have a complementary element in a second code set; requesting and receiving merge instructions for each top-level element for which merge instructions are not provided in the corresponding mapping element; determining whether the merge instructions for each top-level element for which merge instructions are provided require that customizations be merged into the second code set; determining whether the merge instructions for each top-level element set that requires customizations to be merged are valid; requesting and receiving merge instructions for each top-level element for which the merge instructions are not valid; and storing the merge instructions received for each top-level element in the corresponding mapping element. | 03-25-2010 |
20100083228 | Mapping a Class, Method, Package, and/or Pattern to a Component - A program product, apparatuses, and methods provide for the collection of profile information for a component of a software program by generating a data structure that maps at least one method to a component. The method includes a name, and the data structure maps the method to the component using at least a portion of the name of the method. A class or pattern may also be mapped to a component. Furthermore, during profiling, a statistic associated with the execution of the method is determined; the data structure is accessed using the name of the method to determine the associated component; and the determined statistic is associated with the determined component. By doing so, method level and class level information can be aggregated to improve profiling, often leading to a clearer picture of which components are contributing to the performance and memory footprint of large scale software programs. | 04-01-2010 |
20100083229 | APPLICATION BUILDER FOR INDUSTRIAL AUTOMATION - A control system development platform is provided. The platform includes a shell component adapted to support development of a control systems application. An abstract model is associated with the shell component to facilitate development of the control systems applications. | 04-01-2010 |
20100088676 | COMPARING AND MERGING STRUCTURED DOCUMENTS SYNTACTICALLY AND SEMANTICALLY - A method of performing a three-way merge includes receiving first, second, and third versions of a structured document containing first, second, and third pluralities of elements respectively; deserializing the first, second, and third versions to generate first, second, and third tree-structured data models respectively representing the first, second, and third versions; generating an identifier for each node of each data model that is unique within the data model by applying identifier determination rules to a context describing the element corresponding to the node; comparing each identifier in the first data model with each identifier in the second data model to identify each node in the first data model not having matching identifiers with any node in the second data model and to link each pair of nodes having matching identifiers; and applying comparison rules to the contexts of each linked pair of nodes to identify differences therebetween. | 04-08-2010 |
20100095273 | ANALYSIS OF EFFECTS OF A SOFTWARE MAINTENANCE PATCH ON CONFIGURATION ITEMS OF A CMDB - Embodiments of the invention provide a method, a system and a computer program product for analyzing the effect of a software maintenance patch on configuration items of a CMDB. One embodiment, directed to a method, is associated with a CMDB containing information that relates to configuration items (CIs) included in one or more managed configurable systems. The method includes the step of generating a manifest that defines a target system, and contains a description of a maintenance patch disposed to update one or more specified software components. The method further includes using information contained in the manifest to search the CMDB, in order to detect each configurable system in the CMDB that corresponds to the definition of the target system, and contains at least one CI that includes at least one of the specified software components. For a given CI that includes at least one of the specified software components, an identification is made of every other CI in the CMDB that would be affected, if the maintenance patch was used to update each specified software component of the given CI. | 04-15-2010 |
20100107139 | Cooperative Unwrapping Across Intervening Wrappers - A method of accessing layers in a multi-layer software architecture including a first layer, a second layer, and a third layer. The method includes: at the third layer, publishing an interface; and at the first layer, before execution of a first function, registering a callback routine with the third layer using the interface. | 04-29-2010 |
20100107140 | SHARING UNRESOLVED INFORMATION BETWEEN SOFTWARE COMPONENTS - Techniques are disclosed which allow independent software components to share unresolved information with one another. Components may register with a component integration bus (CIB) as a provider or a consumer (or both) for a variety of different data types. The CIB may be further configured to store and share component information with users of the CIB to broker consumer-provider relationships between components included in an integrated solution package. The CIB may also validate the consumer-provider relationships between components included in such a package. Further, the CIB provides information useful to validate the solution package. Using the information from the CIB, components of the solution package are able to resolve unresolved information when the integrated solution is deployed on a remote system. | 04-29-2010 |
20100115492 | Software Analyzer - The present invention provides a software analyzer supporting development of derived products by allowing efficient selection of software components to be simultaneously reutilized or changed based on the past record of developments and changes of software products. A software analyzer according to the present invention analyzes a plurality of software components included in existing software products and correlations between the plurality of software components. The software analyzer includes product line analysis means adapted to create product line configuration data numerically expressing a set of the plurality of software components included in the existing software products, from existing product configuration data including, for each of the existing software products, data on the plurality of software components and data on the correlations between the plurality of software components, inter-component distance analysis means adapted to calculate inter-software-component distances numerically quantifying the correlations between the software components based on the product line configuration data, component cluster analysis means adapted to group the software components based on the inter-software-component distances, and an output section outputting results obtained by the product line analysis means, the inter-component distance analysis means, and the component cluster analysis means. | 05-06-2010 |
20100146483 | DYNAMIC SOFTWARE DOCUMENTATION - A computer device for modifying software documentation for a software package is provided. A first computer is configured to provide the software documentation including help information related to the software package to a second computer and to receive a command from the second computer that corresponds to providing specified help information from the software documentation. The first computer is further configured to transmit the specified help information from the software documentation in response to the command and to receive an identification from the second computer indicating an identity of the second computer and a request from the second computer to modify the help information within the software documentation. The first computer is further configured to modify the help information within the software documentation in accordance to the request in response to determining that the identity of the second computer is authorized to modify the help information within the software documentation. | 06-10-2010 |
20100153916 | METHOD AND SYSTEM FOR TOPOLOGY MODELING - A computer program product is provided. The computer program product includes a computer useable medium having a computer readable program. The computer readable program when executed on a computer causes the computer to generate a topology role in a topology role tier that is included in a topology pattern. Further, the computer readable program when executed on a computer causes the computer to create a component in a component tier that is defined in the topology pattern such that the component corresponds to the topology role. In addition, the computer readable program when executed on a computer causes the computer to map the topology role to a deployment target. | 06-17-2010 |
20100169863 | METHODS FOR DETERMINING RESOURCE DEPENDENCY AND SYSTEMS THEREOF - A method, computer readable medium, and system for automatically determining resource dependency includes automatically identifying with an application processing device one or more dependencies between two or more modules in an application. The application processing device determines one or more ordered lists of executing the modules based on the identified one or more dependencies. The application processing device provides the determined one or more ordered lists of executing the modules in the application. | 07-01-2010 |
20100169864 | INTEGRATION OF INFORMATION DISTRIBUTION SYSTEMS - An integration component assists in the integration of information distribution systems (IDSs). The integration component may help to identify the scope of the systems that are to be integrated using a multi-level top-down approach. The multi-level top-down approach may include five levels: a system software level, a business process level, a business rule level, an interface function level, and a data level. A fault detection component may then check the identified systems to identify potential faults. This check can be performed by representing the business rules as a Transition-Directed-Graph (TDG) and then processing the TDG using generic depth-first search (DFS)-based algorithms. | 07-01-2010 |
20100192125 | METHOD AND SYSTEM FOR DETERMINING INTERFACE COMPATIBILITY BASED ON COMPONENT MODEL - A method and system for determining interface compatibility between components are provided. In the system for determining interface compatibility in component model-based software design, the system includes a compatibility rule manager managing interface compatibility rules, and an interface compatibility validator verifying interface compatibility between components based on the interface compatibility rules. | 07-29-2010 |
20100218167 | METHOD AND APPARATUS FOR SOFTWARE POLICY MANAGEMENT - A system and method for software policy management are provided. A compiled policy-enabled software application includes a policy enforcement point to export an information element to a policy manager. The policy manager includes a policy interpreter having a policy decision point to perform policy decision making based on the received information element from the policy enforcement point. Through a plurality of policy decision points, the policy manager can execute a wide range of policies for different compiled software applications. Policies can be modified centrally in the policy interpreter and changes can affect either one or more of the policy-enabled software applications. A policy manager browser can create and manage the policy decision making performed by the policy interpreter. | 08-26-2010 |
20100235812 | INPUT SUPPORTING METHOD OF VARIABLE NAME IN PROGRAMMING OF PLC - This invention enables a target variable name to be confirmed without inputting all the character string even when a method of giving a name such as allocating a number to the end of the name is performed from the necessity to allocate a variable name having the same meaning to a plurality of different addresses. If narrowed down variable name exists in plurals and one or two or more continuous next character strings match each other among the variable names, the series of character strings without any choice are automatically adopted and confirmed as the character string of the target variable name without waiting for the input of an operator. | 09-16-2010 |
20100242019 | Semantic Intensity Based Decomposition of Software Systems - A computer-implemented technique for analysis of software, is carried out using a semantic intensity calculation module, a coupling calculation module, and a software decomposition module. Software elements are identified in a computer program code, and respective roles of the software elements established. With the semantic intensity calculation module respective semantic intensity metrics are calculated for the software elements according to the roles thereof. With the coupling calculation module semantic intensity metrics are calculated to determine coupling factors between different software elements. With the software decomposition module the software elements are organized into distinct software components according to the coupling factors therebetween. Then, an optimized computer program code is generated from the software components. | 09-23-2010 |
20100242020 | SCA-BASED SYSTEM, AND FILE PARSING METHOD AND APPLICATION GENERATION METHOD THEREOF - The present invention relates to a software communications architecture (SCA)-based system, and a file parsing method and an application generation method thereof. In the present invention, the SCA-based system integrates parsers related to application driving into one parser to generate one integration parser, and implements a parser manager that executes an integration parser function by a common object request broker architecture (CORBA) component. Therefore, when the other manager components need information of descriptor files related to application driving, the other manager components request it from the parser manager of the corresponding information without generating a new parser, and the parser manager provides the corresponding information to the other manager components. | 09-23-2010 |
20100242021 | MANAGED OBJECT MEMBER ARCHITECTURE FOR SOFTWARE DEFINED RADIO - A method for managing a flow of information in an object oriented software environment. A master MOM ( | 09-23-2010 |
20100262953 | SYSTEMS AND METHODS FOR AUTOMATICALLY ENABLING AND DISABLING APPLICATIONS AND WIDGETS WITH A COMPUTING DEVICE BASED ON COMPATIBILITY AND/OR USER PREFERENCE - An application management server may automatically disable applications or widgets that are incompatible with a user's computing device, and automatically re-enable such applications or widgets when the user's computing device is compatible. Auto-disabled applications may be tracked in memory of a server by setting an auto-disabled status indication associated with the disabled application or widget. If an auto-disabled application or widget is upgraded or the user swaps computing devices, thereby resolving the incompatibility, the server may auto-enable such applications and widgets that were previously auto-disabled so that they may be downloaded to or used from the user's computing device. The server may recognize when a software upgrade resolves an incompatibility and prompt a computing device to initiate a synchronization process to receive the auto-enabled application or widget to the computing device or to the user's application server-based locker or profile. | 10-14-2010 |
20100299652 | APPARATUS AND METHOD FOR MANAGING COMPONENTS IN SCA SYSTEM - An apparatus for managing components in an SCA system includes a naming context tree having one or more directories. Each directory has an ID, the ID is assigned to a component to be registered, and the component is registered in the directory having the ID and unregistered from the directory. The apparatus further includes a name server for managing the components registered in the directories of the naming context tree. | 11-25-2010 |
20100306742 | FAST LATE BINDING OF OBJECT PROPERTIES - An apparatus and a method for managing class properties in a computer program is described. Classes are declared. Each class is associated with a corresponding property with at least one class inheriting one or more property corresponding to one or more other classes. A table generator forms a table of property offsets associated with each class. The table is copied forward with each inheritance declaration. A reference to a property of a class is resolved by retrieving the table associated with a current instance's class and resolving from the table associated with the class corresponding to an object from which the property is referenced. | 12-02-2010 |
20100318964 | SOFTWARE EXTENSION ANALYSIS - Multiple structured extension definitions can be obtained, each structured extension definition corresponding to one or more categories, and each structured extension definition being written in a software extension language. Data representing one or more registrations maintained in a format native to a registration store can be accessed, and this data analyzed based at least in part on the multiple structured definitions. In other aspects, a structured extension definition written in a software extension language is obtained. The registration store includes registrations stored in a format native to the registration store and different from the software extension language, and the registration store is modified based on the obtained structured extension definition. | 12-16-2010 |
20100318965 | COMPUTING SYSTEM WITH COMPILE FARM - A computer readable medium is provided and has instructions stored thereon, which, when executed cause a processor of a computing system to execute a method of controlling the computing system. The method includes iteratively running a workload over a period of time, the workload being defined by software components of a software repository of the computing system, measuring power consumption associated with the running of the workload with each iteration and storing data indicative of the power consumption, analyzing the data and identifying, from a result of the analysis, power consumption changes over the period of time, generating a regression profile based on the power consumption changes, and managing the software components in accordance with the regression profile. | 12-16-2010 |
20100318966 | METHOD FOR STARTING SCA-BASED WAVEFORM APPLICATION IN COMPONENT START ORDER - A method for starting an SCA-based waveform application includes defining information on start order of components in a domain profile; and starting a waveform application in the start order according to the information. Further, the waveform application is executed by using the method including: creating an application X by an application factory; parsing, by the application factory, the information on the start order of the components defined in the domain profile to be transmitted to the application X; receiving the information from the application X and storing the information in the assembly controller; and calling a start of the application X when a start command is received; calling a start of the assembly controller by the application X; executing components in the start order based on the information stored in the assembly controller. | 12-16-2010 |
20100325613 | Documentation Roadmaps and Community Networking for Developers on Large Projects - A version control system includes a mechanism for a learning roadmap based on information available from a source repository. More particularly, the mechanism generates an easily understandable timeline of a project and a directory of developers based on information available in the version control system that contains the source content of a project. The timeline for the project may be tied to the directory of developers. Under each date in the timeline, a list of developers and their roles and commits may be listed. | 12-23-2010 |
20100333066 | METHOD AND SYSTEM FOR MANAGING SOFTWARE ISSUES - A method of managing software issues includes receiving issue data from a remote host, where the issue data is related to an issue associated with a software application installed on the remote host. The method identifies a potential solution for the issue and sends solution data to the remote host, where the solution data is related to the identified potential solution. Feedback data may be received from the remote host, where the feedback data is indicative of a degree to which the identified potential solution was effective in resolving the issue. | 12-30-2010 |
20110010690 | System and Method of Automatically Transforming Serial Streaming Programs Into Parallel Streaming Programs - A commerce transaction is controlled by transforming serial code segments into parallel code segments. An application is parsed by determining the code segments that must be executed as serial code segments and the code segments that can be executed as parallel code segments. A parallel file is generated for each parallel code segment. The parallel file contains the parallel code segment and the code segments of the application called by the parallel code segment. The application executes through the serial code segments and parallel code segments. When encountering the parallel file, a tag is written to the output stream to reserve a position to write an output value of the parallel file when complete. The parallel file is executed simultaneously with the serial code segment, and the output value of the parallel file is written in the reserved position of the output stream when the parallel file execution completes. | 01-13-2011 |
20110023016 | METHOD FOR APPLICATION AUTHORING EMPLOYING A PRE-CERTIFIED MULTI-PLATFORM MASTER APPLICATION TEMPLATE - A computer system is used to create an application. A multi-platform application intended for two or more target platforms is created using an authoring environment. The application is converted into a multi-platform master application template by creating an application representation and creating associated metadata that define at least one allowable modification that may be made to the application representation. For each target platform, an application is created from the multi-platform master application template suitable for the target platform, and the application and multi-platform master application template are submitted to a certification body for certification on the target platform. The certification process affirms that the application, with any modification to the application specified by the multi-platform master application template metadata, meets all requirements for certification. The certified multi-platform master application template is used to create a certified application for each target platform. | 01-27-2011 |
20110023017 | OBJECT-ORIENTED SYSTEM FOR CREATING AND MANAGING WEBSITES AND THEIR CONTENT - The invention teaches a method for creating and managing a website as an object oriented system, comprising: providing on a system server a plurality of hierarchical classes of objects, each of the classes representing one aspect of the storage, presentation and logic of a website; providing on a web server an interface operable to present representations of objects instantiating the plurality of hierarchical classes and receive commands meant to one of: instantiate a new object, destroy a presented object, and change a property of a presented object; and storing on a database server objects as a traversable tree in accordance with the plurality of hierarchical classes. | 01-27-2011 |
20110035729 | GENERATING AND RESOLVING COMPONENT NAMES IN AN INTEGRATED DEVELOPMENT ENVIRONMENT - A component name manager operates within an integrated development environment to assist developers in creating dynamic websites and Internet applications. The component name manager identifies an input field displayed on a graphical user interface of an object-oriented software development environment. The input field uses a fully-qualified name of a software component for accessing to access instructions and data associated with the software component and located at an application server. In response to receiving an input associated with the input field, the component name manager displays a list of qualified names of software components available for use in the object-oriented software development environment. Each of the qualified names identifies a path for accessing a corresponding software component. The component name manager can resolve fully qualified names by accessing one or more of an application file, an administrator interface, project level mappings, and global level preference mappings. | 02-10-2011 |
20110041118 | MENU DRIVEN COMPONENT BASED BUILD SYSTEM - Particular embodiments generally relate to an implementation of a build engine. In one embodiment, a method for implementing a build engine includes receiving at least one menu that includes one or more sections, wherein each of the one or more sections indicates one or more libraries, and wherein each of the one or more libraries is associated with one or more software components. The method also includes parsing each of the one or more sections to determine the one or more libraries and the one or more software components. The method also includes building, by a computer processor, executable software code based on the one or more libraries and the one or more of the software components. | 02-17-2011 |
20110041119 | STORING Z/OS PRODUCT TAG INFORMATION WITHIN Z/OS LOAD MODULE DATASETS - A method, system and computer-usable medium are disclosed for managing software product information in a z/OS environment. Information associated with a software product is processed to generate product tag information in the product's load module data set. The product tag information is variously embedded in a z/OS load module file, IDR DATA associated with a z/OS load module file, or in an extra z/OS Control Section (CSECT). Product information discovery operations are then performed on the product tag information to acquire associated product information. A z/OS load module file, IDR DATA associated with a z/OS load module file, or an extra z/OS CSECT is scanned for product tag information. If discovered, it is extracted and then processed to generate associated product information, which is then stored in a repository of software product information. | 02-17-2011 |
20110055809 | TYPED CONFIGURATION MANAGEMENT IN PROGRAMMING LANGUAGES - A typed configuration management method includes instantiating a typed configuration structure including parameters configured to store values. Each of the parameters includes a data type. The method also includes initializing an application on a computer system that includes the typed configuration structure, loading the values from the typed configuration structure into system memory of the computer system, and applying validation logic to the values to determine whether the values match corresponding data types specified for the parameters. In response to the determination, the method includes storing values that pass the validation logic in the parameters of the typed configuration structure, and loading the typed configuration structure, including the values passing the validation logic, into the system memory. Another method provides compile time loading and validation of a typed configuration structure, as well as compile time checking of program code that will use the typed configuration structure at runtime. | 03-03-2011 |
20110055810 | SYSTEMS AND METHODS FOR REGISTERING SOFTWARE MANAGEMENT COMPONENT TYPES IN A MANAGED NETWORK - Embodiments relate to systems and methods for registering management software component types in a managed network. In embodiments, a central registration server can scan a managed network to identify different types and configurations of target machines. The registration server can, for instance, perform an authorization process on some or all targets in a network, and determine a management software component type required by or compatible with each target. The Different target machines may have requirements for different management software component types depending, for instance, on the operating system or other resources installed on each target. Once a management software component type has been identified, the registration server can take an inventory of further resources hosted on the target, as well as identify types of management agents that can be distributed to the target to registration to remote management services, such as configuration management or performance monitoring services. | 03-03-2011 |
20110055811 | Discovery, Analysis, and Visualization of Dependencies - Product data pertaining to a plurality of products is gathered from a plurality of sources. Dependency information for the plurality of products is extracted from the product data. The dependency information is analyzed to determine dependencies for each product of the plurality of products. The dependencies for each product of the plurality of products are displayed to a user. | 03-03-2011 |
20110055812 | SHARABLE DEVELOPMENT ENVIRONMENT BOOKMARKS FOR FUNCTIONAL/DATA FLOW - An embodiment of the invention provides relative bookmarks that are sharable between developers engaged in product development utilizing integrated design environment applications. The relative bookmarks are sharable in that they can be exported, imported, activated and deactivated. The relative bookmarks are relative in that they do not rely on the original code line and contain at least function and/or data flow information, facilitating quick identification of relevant lines of code that have been previously bookmarked. The relative bookmarks can also be utilized to insert breakpoints. | 03-03-2011 |
20110061041 | RELIABILITY AND AVAILABILITY MODELING OF A SOFTWARE APPLICATION - Reliability and availability modeling of a software application is provided. A reliability and availability model is generated in the form of a white-box model of a software application. An existing model of the software application's structure and behaviour is inspected and/or the software application is inspected. The accuracy of the reliability and availability model is determined and reliability and availability metrics for the software application are calculated. Additional input parameters relating to the software application's performance may be determined and the additional input parameters may be added to the reliability and availability model. | 03-10-2011 |
20110067003 | SYSTEM AND METHOD OF SUBSTITUTING PARAMETER SETS IN SELF-CONTAINED MINI-APPLICATIONS - Disclosed are systems and methods of building a default set of parameters into a software application by defining a widget template having associated parameter schema and then instantiating a widget by substituting a new set of application parameters for the built-in defaults such that the new parameters meet the same constraints defined for the default parameters. Aspects of the invention also include testing the original application containing the default parameters, along with the parameter substitution process itself, using a Statistical Software Testing Methodology (SSTM) to ensure the application meets a pre-determined level of quality. | 03-17-2011 |
20110072415 | PROCESS OF AUTOMATIC MATCHING OF SOFTWARE - The invention relates to a process for the automatic matching of a control software component to a control unit net work in order to permit communication between control software components of the control unit network, whereby the control unit network-independent communication commands of a control software component in the program code are replaced by control unit network-dependent commands. | 03-24-2011 |
20110099536 | Determining Context Specific Content - In one illustrative embodiment, a computer-implemented method for identifying program components, generates, by a processor unit, associations between the program components stored in a computer usable storage medium to create a first set of relationships, and assigns, by the processor unit, a probability to each relationship in the first set of relationships to create a second set of relationships, wherein the probability indicates a strength of the associations between the program components. | 04-28-2011 |
20110099537 | EVENT HANDLING FOR UNMANAGED CODE - Many computer applications involve event driven programming. Unfortunately, it may be burdensome on application developers to develop event handlers in unmanaged code for all relevant events within their computer application. For example, when using COM objects in connection with event handling, the burden of lifetime management may be placed on the application developer. Accordingly, one or more systems and/or techniques for event handling in unmanaged code are disclosed herein. A delegate comprising a first interface and a second interface is provided. The delegate may receive event data from a software platform connected to the first interface and may notify a function of a process connected to the second interface. The delegate self destructs when both the computing platform and the process have released their connections to the respective interfaces, thus mitigating manual coding of lifetime management functionality within the process. | 04-28-2011 |
20110119653 | INCREMENTAL PACKAGING - A project directory structure of an application or service is mapped to a package directory structure. A package is built for the application or service by copying files from the project directory structure to the package directory structure in accordance with the mapping. An event trigger is detected, wherein the event trigger is one of a new file, a modified file, or a deleted file in the project directory structure. An updated package is built for the application or service by performing an appropriate one of copying the new file to the package directory structure, replacing an existing file in the package directory structure with the modified file, or deleting a file in the package directory structure that corresponds to the deleted file in the project directory structure. | 05-19-2011 |
20110145787 | BUSINESS OBJECT CHANGE MANAGEMENT USING RELEASE STATUS CODES - A computer-implemented system may include a data store to store business data, an application platform, and a business application. The application platform may include a repository to store metadata defining a plurality of business objects, each of the business objects comprising a respective model of data and associated logic, each business object associated with respective business object entities, and a framework in communication with the repository to provide access to the business data. The business application is to access the data via the framework and based on the metadata, wherein the metadata associates a first plurality of the business object entities with a RELEASED release status code, and wherein the metadata associates a second plurality of the business object entities with a DEPRECATED release status code. | 06-16-2011 |
20110154291 | SYSTEM AND METHOD FOR FACILITATING FLOW DESIGN FOR MULTIMODAL COMMUNICATION APPLICATIONS - Methods, systems, and computer-readable storage media are disclosed that facilitate flow design for multimodal communication applications. Aspects for selecting, generating, and/or arranging application modules are described which include providing a graphical user interface (GUI) and receiving a user input via the GUI. The application modules are interchangeable within an interchangeable sequence of application modules based on the user input. The interchangeable sequence includes a first application module configured to receive data via a first communication channel, and a second application module configured to receive data via a second communication channel disparate from the first communication channel. | 06-23-2011 |
20110161929 | USING AN ENTERPRISE MESSAGING BUS TO AUTOMATICALLY INFLUENCE THE PROCESS OF SOFTWARE COMPILATION AND PACKAGING FOR USE BY A COLLABORATIVE PROJECT - A build system executes a build process using an enterprise messaging bus, a plurality of services, and a plurality of shims, where each of the services do not natively communicate with the enterprise messaging bus. A shim processes a message between a service and an enterprise message bus. The shim further communicates the processed message between the service and the enterprise message bus. The shim includes a receive shim that receives messages from the enterprise message bus, converts the received message into a format native to the service, and forwards the converted message to the service. The shim also includes a transmit shim that receives messages from the service, converts the received message into a format native to the enterprise message bus, and forwards the converted message to the enterprise message bus. | 06-30-2011 |
20110161930 | MELDING OF MEDIATION FLOW SERVICE COMPONENT ARCHITECTURE (SCA) COMPONENTS - Embodiments of the present invention provide a method, system and computer program product for melding mediation and adaptation modules of a service component architecture (SCA) system. A method for melding mediation and adaptation modules of an SCA system can include selecting each of a mediation module and an adaptation module in an integrated development tool executing in memory by a processor of a computer and loading respectively different descriptor files for each of the mediation module and the adaptation module. The method further can include combining descriptors from the different descriptor files into a single descriptor file for a melded module. Finally, the method can include modifying names and wiring descriptors in the single descriptor file for the melded module to account for a combination of the mediation component and the adaptation component in the melded component. | 06-30-2011 |
20110167407 | SYSTEM AND METHOD FOR SOFTWARE DATA REFERENCE OBFUSCATION - Disclosed herein are systems, methods, and computer-readable storage media for obfuscating software data references. The obfuscation process locates pointers to data within source code and loads the pointers into an ordered set of pools. The process further shuffles the pointers in the ordered set of pools and adds a function within the source code that when executed uses the ordered set of pools to retrieve the data. The obfuscation process utilizes pool entry shuffling, pool chaining shuffling and cross-pointer shuffling. | 07-07-2011 |
20110231817 | SYSTEM AND METHOD FOR EVALUATING AND SELECTING SOFTWARE COMPONENTS AND SERVICES - A system that includes one or more computer processors is configured to receive parameters relating to non-functional attributes of a proposed software component, parameters relating to non-functional attributes of one or more available software components, and a weight for each of the non-functional attributes. The system calculates a quality and a risk for each available software component as a function of the parameters of the proposed software component, the parameters for the one or more available software components, and the weight for each of the non-functional attributes. The system outputs to a display device one or more of the quality and the risk for the one or more available software components. | 09-22-2011 |
20110231818 | Method and device for operating software-controlled devices - The method and the device serve for operating software-controlled devices. At least a portion of software for controlling at least two different devices is stored in the area of a data storage. The software is activatable such that, after a selection of a concrete device, the control software required for this device is made available for the user and an operation of the device becomes possible. | 09-22-2011 |
20110252402 | ENHANCING SOFTWARE APPLICATION FEATURES AND CONTENT OBJECTS - A method of enhancing features in a computing environment wherein a software application comprising compiled source code is executed, the method comprising inserting at least one content object into a canvas page of the software application. Each content object comprises code defining functionality attributed to the content object. The content object code is executed in response to interaction with the content object thereby to supplement host software application functionality with the attributed functionality. | 10-13-2011 |
20110258598 | SERVER SIDE APPLICATION INTEGRATION FRAMEWORK - A flexible, platform-independent integration infrastructure is provided. The integration infrastructure may include an integration bridge and at least one plug-in, where the at least one plug-in may include translation rules, mapping rules, and other information associated with a component coupled to the plug-in. The translation rules, mapping rules, and other information may be used by the integration bridge during a mapping process to control communication between components. Based on the rules and information, a mapping translator of the integration bridge converts data received from component into a form readable by another component. | 10-20-2011 |
20110265063 | COMPARING SOURCE CODE USING CODE STATEMENT STRUCTURES - A computer system identifies a plurality of source code files to be compared, parses each source code file to identify a code statement structure present in the file, and compares the plurality of source code files using corresponding code statement structures. | 10-27-2011 |
20110271251 | ACCESS CONTROL IN MODULES FOR SOFTWARE DEVELOPMENT - The disclosed embodiments provide a system that provides access control for a software program. During operation, the system identifies a member of a module to be used in the software program. Next, the system infers the visibility of the member based on the accessibility of the member. Finally, the system uses the visibility and the accessibility to provide access control during the life cycle of the software program. | 11-03-2011 |
20110302558 | System and Method for Constructing an Application Using Distributed Functionalities - A system and method are disclosed for factoring the functionalities within one or more applications into separate entities, storing them locally and/or distributing them across a network of servers such that code reusable across applications is updatable at one place, the user of an application sees only the interface relevant, to the task at hand, the interface for the user is consistent across applications utilizing the same functionality while at the same time it remains clear to the user which context the user is in, and additional functionalities may be added and subtracted during run time without recompiling the application or reinitialising the application. | 12-08-2011 |
20110307862 | 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. | 12-15-2011 |
20110314449 | METHOD AND SYSTEM FOR ESTIMATING EFFORT FOR MAINTENANCE OF SOFTWARE - The present invention provides a method, a system, and a computer program product for determining an effort associated with the maintenance of software. The method, the system, and the computer program product enable receiving values corresponding to predefined factors, which are segregated into corrective factors, preventive factors, perfective factors, and adaptive factors. A corrective effort is determined based on the corrective factors and predefined rules. Thereafter, a preventive effort is determined based on the preventive factors, the predefined rules, and the corrective effort. Thereafter, a perfective effort is determined based on the perfective factors, the predefined rules, and the corrective effort. Subsequently, an adaptive effort is determined based on the adaptive factors, the predefined rules, the corrective effort, the preventive effort, and the perfective effort. A total effort is then generated based on the corrective effort, the preventive effort, the perfective effort, and the adaptive effort. | 12-22-2011 |
20110321011 | APPLICATION SERVER WITH A PROTOCOL-NEUTRAL PROGRAMMING MODEL FOR DEVELOPING TELECOMMUNICATIONS-BASED APPLICATIONS - An application server is described for development of telecommunications-based software applications. The application server provides a protocol-neutral programming model for application developers. Rather than having to account for specific protocol entry points into the server, all interactions in the server are abstracted as asynchronous events through the event broker layer. State management and concurrency are implemented as an actor-based model, where each actor owns its own segment of state and other actors wishing to update that state send asynchronous events to the owner. Thus, any communication in the various protocols can be expressed as an asynchronous event passed to, from and between the actors, who are each responsible for maintaining their own segment of state locally. This architecture allows multiple protocols to be consumed in one process, allow applications sessions to span multiple environments and protocols, and allows the programming model to be decoupled from any particular protocol entry point. | 12-29-2011 |
20120005653 | CORRELATING SOFTWARE MANAGEMENT FACILITY DATA WITH PRODUCT INVENTORY DATA - An approach is provided that retrieves aggregate usage data from a storage media, with the aggregate usage data including a number of system management facility records that were previously gathered by a usage monitor that is running on the computer system. A list of a number of loadable software programs that are executable from the computer system is also gathered. The aggregate usage data and the list of loadable software programs are then correlated, with the correlation resulting in a software usage analysis. | 01-05-2012 |
20120005654 | REPOSITORY RELATIONSHIP PROGRAMMING - Embodiments of systems, methods and computer program products are described for implementing repository relationship programming. Implementations described herein describe processes for implementing a union of concerns, integrating concerns, assembling concerns and separating concerns. | 01-05-2012 |
20120060148 | ASSIGNING RUNTIME ARTIFACTS TO SOFTWARE COMPONENTS - A method, system and computer program product 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. | 03-08-2012 |
20120060149 | INTEGRATED MULTIMEDIA APPLICATION FOR MOBILE DEVICES - A method and a device are disclosed for downloading an integrated multimedia mobile application including a description of a multimedia content accessible from within the mobile downloadable application, a player to play the multimedia content, and the multimedia content. In an example typical operation, a user views a list of downloadable mobile applications, such as Apple Corporation's iPhone apps, listed as icons, selects an integrated multimedia application, reads a description of the content within the selected mobile application, and launches a player from within the application to play the content. Such functionality may be provided by a provider such as a mobile communication service provider, a content provider, an application provider, or a combination thereof. | 03-08-2012 |
20120079454 | EXPRESSING EQUIVALENCY RELATIONSHIPS WITH IDENTITY GRAPHS - A synchronization system is described herein that synchronizes two environments by correctly matching identity objects in a source environment with related objects in a target environment. In addition to matching identities based on primitive attributes, the system matches identities across multiple heterogeneous environments based on their relative positions in an identity graph. The system builds the identity graph by first matching some identity objects based on primitive attribute value comparisons. The system fills in the remainder of the identity graph by comparing references to/from the matched identity objects. The combination of attribute value comparisons and comparing references enables identity-aware applications to complete a single identity graph, determine the equivalency of identities in this graph, and apply policy based on this new relationship. | 03-29-2012 |
20120096433 | DEPENDENCY RESOLUTION IN POLYPHASIC MODULES - Some embodiments provide a system that facilitates the development, maintenance, and execution of a software program. During operation, the system obtains a module declaration for a module to be used in the software program. Next, the system resolves one or more dependencies of the module using the module declaration and a list of available modules for the software program. Finally, the system uses the resolved dependencies to manage the software program throughout the life cycle of the software program. | 04-19-2012 |
20120096434 | SYSTEM AND METHOD FOR DETECTING PREVENTATIVE MAINTENANCE OPERATIONS IN COMPUTER SOURCE CODE - The invention relates to a system and method for identifying occurrences of preventive maintenance on computer source code. The method comprises analyzing source code, defining data sets associated with characteristics of the source code, and applying an operation algorithm to the data sets to thereby identify occurrences of preventive maintenance operations that were carried out on the source code. A first instance of a source code and a second instance of the source code are preferably analyzed, wherein the second instance of the source code is a revised version of the first instance of the source code, a first data set associated with the first instance of the source code and a second data set associated with the second instance of the source code are preferably defined, and the operation algorithm is preferably applied to the first data set and the second data set to thereby identify at least one occurrence of a preventive maintenance operation that was carried out on the source code. | 04-19-2012 |
20120110549 | Code Breakage Detection Using Source Code History Background - An illustrative embodiment of a computer-implemented process for detecting code breakage using source code change history receives a point in time within an identified range of time to form a selected time, receives a set of source files associated with the a selected time, receives a set of history files associated with the received set of source files and initializes a workspace in a sandbox using the set of source files and the set of history files. The computer-implemented process incrementally executes the received set of source files from the selected time forward, determines whether a code break occurs and responsive to a determination that the code break occurs, presents a list of files. The computer-implemented process receives an identified file from the list of files to form a suspect file, and receives a correction for the suspect file. | 05-03-2012 |
20120117538 | CHARACTERIZING INTERFACE EVOLUTION AND CONSUMER ROLES IN MODULE SYSTEMS - The disclosed embodiments provide a system that facilitates the development and maintenance of a software program. This system includes a software development kit (SDK) and a runtime system for the software program. During operation, the system obtains a role associated with a dependency of a consumer in the software program on an interface. Next, the system obtains a compatibility policy for the interface. Finally, the system uses the role and the compatibility policy to manage use of the interface by the consumer in the software program. | 05-10-2012 |
20120117539 | Capability model for deploying componentized applications - Disclosed are systems and methods for deploying a componentized application using a deployment tool to deploy an application expressing a requirement for a first capability associated with a second capability, and to find a first capability provider providing the first capability, where the second capability is provided by a second capability provider, and the second capability is dynamically associated with the first capability provider. | 05-10-2012 |
20120117540 | METHOD AND COMPUTER PROGRAM PRODUCT FOR CREATING A QUESTIONNAIRE INTERFACE PROGRAM - A computer program including an interface that may be used by a content designer to manipulate information stored in the database. The content designer may design one or more questionnaire pages, to be included in a questionnaire site, which may be built into a questionnaire interface program by a compiler. The resulting questionnaire interface site may be accessed and manipulated by a client user to respond to the questions included therein. Validation responses may be defined by a content designer, against which responses by a client user may be compared. The various elements included herein may be connected through a network, which may be accessed through a user interface terminal. | 05-10-2012 |
20120137271 | DECOUPLED DEVELOPMENT IN A SHARE DEVELOPMENT SYSTEM - A computer-implemented method of optimizing software components. The method may include receiving a software component including a layered hierarchy of structure packages, main packages, and common packages each including objects, grouping common packages into groups according to pre-determined criteria, encapsulating each group with an encapsulation package, wherein the encapsulation package is one of a structure package and a main package, allowing objects in the encapsulation package to communicate directly by bypassing common packages in the encapsulation package, and eliminating package interfaces of the common packages in the encapsulation package that are solely used for communicating with other common packages in the encapsulation package. | 05-31-2012 |
20120144367 | EVENTS FIRED PRE- AND POST-METHOD EXECUTION - Customization of source code of a software program like a business application is enabled without modifying the source code of the software. External pieces of source code may be executed prior to, and/or following the invocation of selected methods. The external methods executed prior to a designated method call may change the parameter values that the designated method gets called with, and the methods executed after the designated method has been called may change a value returned from the designated method. | 06-07-2012 |
20120144368 | COMPONENT MODEL FOR ANALYTIC APPLICATIONS SUPPORTING PARAMETERIZATION - In an aspect there is provided a method. The method may include defining an application to include at least one component, the at least one component including at least one parameter; executing the application, wherein the at least one parameter receives a value to enable the application to produce data, wherein the at least one parameter is received from at least one of another component, a user interface, or another program; and providing the produced data to a user interface. Related apparatus, systems, techniques, and articles are also described. | 06-07-2012 |
20120151438 | VISUAL CUES BASED ON FILE TYPE - The subject disclosure relates to providing more effective visual cues for distinguishing between files based upon file types. Given that users typically browse and select files based upon their file types, and further that various collections of files often share identical or similar naming conventions, the subject disclosure provides a useful mechanism to reduce the need for close inspection of file names in order to locate desired files. In particular, various file types can be assigned to a set of groups and each group can be associated with a particular color. Thus, visual representations (e.g., icons or tabs) of the various files can be presented with a color-coded element to serve as the visual cue. | 06-14-2012 |
20120151439 | LIFECYCLE STABLE USER INTERFACE ADAPTATIONS - Various embodiments of systems and methods for lifecycle stable user interface adaptations are described herein. All adaptations done by partners/key users/end users to a user interface of a computer software application are preserved during the lifecycle of the application. In one aspect, the adaptations are persisted as additional metadata used for the generation of the user interface. In another aspect, the lifecycle stability is achieved by attaching the adaptations to semantically coherent set of fields placed in the UI that reappear in future releases of the computer software application. | 06-14-2012 |
20120151440 | SOFTWARE LIBRARY RECONSTRUCTION DEVICE, SOFTWARE LIBRARY RECONSTRUCTION METHOD, AND NAVIGATION DEVICE USING THIS SOFTWARE LIBRARY RECONSTRUCTION METHOD - Disclosed is a software library reconstruction device which extracts program elements which are used for the execution of a function from among program elements which construct a general-purpose software library | 06-14-2012 |
20120151441 | EFFICIENT GENERATION OF EXECUTABLE FILE FROM PROGRAM FILES WHEN SOME OF THE PROGRAM FILES EXPRESSLY INCORPORATE OTHER PROGRAM FILES - Efficient generation of executable file from program files when some of the program files expressly incorporate other program files. In an embodiment, dependency information representing which program files (conditionally or unconditionally) incorporate other program files is generated and stored in a secondary (non-volatile) storage. When some program files are modified, the dependency information is used to identify for recompilation all the program files that incorporate any of the modified program files. The modified program files and the identified program files are recompiled and the executable file is regenerated. | 06-14-2012 |
20120159434 | CODE CLONE NOTIFICATION AND ARCHITECTURAL CHANGE VISUALIZATION - A code verification system is described herein that provides augmented code review with code clone analysis and visualization to help software developers automatically identify similar instances of the same code and to visualize differences in versions of software code over time. The system uses code clone search technology to identify code clones and to present the user with information about similar code as the developer makes changes. The system may provide automated notification to the developer or to other teams as changes are made to code segments with one or more related clones. The code verification system also helps the developer to understand architectural evolution of a body of software code. The code verification system provides an analysis component for determining architectural differences based on the code clone detection result between the two versions of the software code base. The code verification system also provides a user interface component for displaying identified differences to developers and others involved with the software development process in intuitive and useful ways. | 06-21-2012 |
20120159435 | SUPPORT FOR TEMPORALLY ASYNCHRONOUS INTERFACE EXTENSIONS - A data object can be received at a first time at a first inbound interface of a first software component from a second software component. The first inbound interface can be configured to map a first feature of the data object to at least one first internal data structure of the first software component but not configured to map a second data feature of the data object to any corresponding internal data structure of the first software component. Characteristic information of the second data feature can be stored in a generic data container added to the internal data structure. The characteristic information can include a value of the second data feature and metadata describing an identifier of the second data feature. A reconstructed data object can be formed at a second time subsequent to the first time. The reconstructing can include recreating the second data feature based on the characteristic information retrieved from the generic data container and combining the recreated second data feature with the first data feature retrieved from the at least one first internal data structure. Related methods, systems, and articles of manufacture are disclosed. | 06-21-2012 |
20120159436 | Method of bypassing an autosar software component of an autosar software system - A method of bypassing an AUTOSAR software component of an AUTOSAR software system including two or more AUTOSAR software components connected via a runtime environment (RTE). To get a high flexibility and a close relationship to the AUTOSAR model of development an custom AUTOSAR software component is used to bypass all or part of the functionality of a selected AUTOSAR software component and provide that functionality to another AUTOSAR software component candidate or on some external system. | 06-21-2012 |
20120159437 | MANAGING LIFECYCLE OF OBJECTS - A method 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. | 06-21-2012 |
20120174064 | MANAGEMENT OF OBJECTS WITHIN A META-DATA REPOSITORY - At least one binary relationship defining an enhancement to a standard meta-object instance can be stored in a meta-data repository. The at least one binary relationship can be specified at design time and can define a dependency required to create an enhanced meta-object instance that includes the standard meta-object instance and the enhancement. The standard meta-object instance can be provided by a core software platform. The enhanced meta-object can include at least one additional feature relating to an external software component integrated into the core software platform. At run time, a request for a custom instance of a data structure based on the enhanced meta-object instance can be received. The custom instance can include a meta-object instance extension specified at design time by a service consumer of the core software platform. Also at run time, a transitive shell representing the custom instance of the data structure can be generated, for example by traversing the at least one binary relationship to create a template meta-object and applying the meta-object instance extension to the template meta-object to create a current version of the custom instance of the data structure. Related systems, methods, and computer program products are described. | 07-05-2012 |
20120185824 | MECHANISM FOR DYNAMICALLY RESOLVING POLYMORPHIC TYPE DEPENDENCIES BETWEEN PARALLEL HETEROGENOUS RUN-TIME ENVIRONMENTS - A mechanism for dynamically resolving polymorphic type dependencies between parallel heterogenous run-time environments is provided. The mechanism comprises a registry of class types for software objects, in which each class type is linked to a hierarchy of bindings rooted at the binding for that class type with descendent bindings in the hierarchy relating to more specific sub-classes. At run-time a pointer to an object is received, and the received static type of that pointer can be looked up in the registry to determine the location in the hierarchy of bindings at which to make an initial query for the most specific sub-class compatible with the dynamic type of the object. Subsequently, beginning at the determined location in the hierarchy of bindings, the most specific sub-class compatible with the dynamic type of the object is determined, and a run-time binding based on the most specific sub-class identified can be selected. | 07-19-2012 |
20120185825 | Method and Apparatus for Programming Software Components - A method and apparatus are disclosed for programming software components that treats software components as the basic unit of abstraction and computation. A software component is encapsulated and classes and other program entities, such as data fields and methods, within a given component do not exist beyond a component boundary. A component interacts with other components only by means of a defined set of input and output ports. A component can inherit and implement ports declared in a template and can declare and implement new ports. A component can only access the external environment through its output ports. An output port of one component can only be connected to a conforming input port of another component. A connect statement is an explicit plumbing operation for connecting components together. Interactions between components are loosely coupled. A related set of templates can be grouped together to form a group. | 07-19-2012 |
20120185826 | SURVIVAL RULE USAGE BY SOFTWARE AGENTS - A method for determining the lifespan of an agent utilizing a rule engine and a set of canonical survival rules, in an execution environment comprising collecting a survival rule, asserting a survival data into a working memory and executing the rule engine with the set of survival rules and the working memory. | 07-19-2012 |
20120192151 | SOFTWARE DEVELOPMENT TOOL - A method for improving the development and/or review of a computer program. The method comprises the steps of: adapting one or more design side components of the computer program to send and receive information on changes that occur therein; adapting one or more code side components of the computer program to send and receive information on changes that occur therein; synchronising design side components and code side components by conveying details of a change in a design side component to one or more corresponding code side components and to one or more corresponding design side components to update the contents of said components and by conveying details of a change in a code side component to one or more corresponding design side components and one or more corresponding code side components to update the contents of said components. | 07-26-2012 |
20120204144 | METHOD FOR KEEPING A WEB SESSION ALIVE IN A WEB APPLICATION - A method keeps a web session alive for an amount of time allowing to keep a limited amount of data on the Internet information server and manage individually the session timeout characteristics of the web session in the web application. The method automatically refreshes the web pages in the background without any further user interaction. Thereby, a portion of code added effectively creates a hidden postback that keeps alive the session's state. By a class library, the user is enabled at the engineering level to manage a session timeout state and to eliminate a premature timeout thereby eliminating any risk of possible data loss. | 08-09-2012 |
20120204145 | Method and apparatus for executing software applications - Consumer electronic devices, such as e.g. high-definition movie players for removable storage media such as optical discs, may provide possibilities for advanced interactivity for the user, implemented as software applications. A question arising generally with such software applications is what the life cycle of such an application is, and who may control it. The invention provides a method for executing software applications within a playback device for audio-video data, wherein data from a first removable storage medium are read for a software application to be executed within said playback device, and the data comprise an indication defining a termination condition for the application. Based on said termination code and depending on how the medium holding the application is ejected, the application is terminated or may survive. | 08-09-2012 |
20120204146 | Method and apparatus for executing software applications - Consumer electronic devices, such as e.g. high-definition movie players for removable storage media such as optical discs, may provide possibilities for advanced interactivity for the user, implemented as software applications. A question arising generally with such software applications is what the life cycle of such an application is, and who may control it. The invention provides a method for executing software applications within a playback device for audio-video data, wherein data from a first removable storage medium are read for a software application to be executed within said playback device, and the data comprise an indication defining a termination condition for the application. Based on said termination code and depending on how the medium holding the application is ejected, the application is terminated or may survive. | 08-09-2012 |
20120204147 | Method and apparatus for executing software applications - Consumer electronic devices, such as e.g. high-definition movie players for removable storage media such as optical discs, may provide possibilities for advanced interactivity for the user, implemented as software applications. A question arising generally with such software applications is what the life cycle of such an application is, and who may control it. The invention provides a method for executing software applications within a playback device for audio-video data, wherein data from a first removable storage medium are read for a software application to be executed within said playback device, and the data comprise an indication defining a termination condition for the application. Based on said termination code and depending on how the medium holding the application is ejected, the application is terminated or may survive. | 08-09-2012 |
20120204148 | MANAGING AN APPLICATION SOFTWARE PARTITION - A computer implemented method, apparatus, and computer usable program code for managing a software partition in logical partitioned data processing system. A virtual root process is created for the software partition, wherein the virtual root process functions as a root process for the software partition. The set of child processes is re-parented to the virtual root process in response to termination of a process having a set of child processes. | 08-09-2012 |
20120210300 | MECHANISM FOR COMPATIBILITY AND PRESERVING FRAMEWORK REFACTORING - The subject disclosure relates to enabling the evolution of a framework by providing public surface area factorings for both old and new public surface areas. The factoring can mitigate changes in the implementation of existing distributions of framework. The factoring can also mitigate breaking existing binaries. Further, the factoring can be provided while mitigating a degradation in the security guarantees of the linking model. The factorings can be applied for runtime and/or for a development toolkit. Thus, multiple, almost simultaneous, interoperable views of a framework implementation can be enabled at runtime and/or at design or build time. The views can represent different versions of the framework. | 08-16-2012 |
20120210301 | METHOD, SYSTEM AND APPARATUS FOR MANAGING THE RE-USE OF SOFTWARE REQUIREMENTS - According to embodiments described in the specification, a method, system and apparatus for managing software requirements is provided. The method comprises storing a source descriptor in a memory in association with a first module, the descriptor comprising a requirement for a proposed software application; receiving a request for the source descriptor; and creating and storing, responsive to the request, a subscribing descriptor, the subscribing descriptor being a copy of the source descriptor and including an identifier of the source descriptor, the subscribing descriptor being stored in the memory in association with a second module. | 08-16-2012 |
20120210302 | Method and apparatus for executing software applications - Consumer electronic devices, such as e.g. high-definition movie players for removable storage media such as optical discs, may provide possibilities for advanced interactivity for the user, implemented as software applications. A question arising generally with such software applications is what the life cycle of such an application is, and who may control it. The invention provides a method for executing software applications within a playback device for audio-video data, wherein data from a first removable storage medium are read for a software application to be executed within said playback device, and the data comprise an indication defining a termination condition for the application. Based on said termination code and depending on how the medium holding the application is ejected, the application is terminated or may survive. | 08-16-2012 |
20120210303 | SYSTEM AND METHOD FOR REVISING BOOLEAN AND ARITHMETIC OPERATIONS - Disclosed herein are systems, methods, computer readable media and special purpose processors for obfuscating code. The method includes extracting an operation within program code, selecting a formula to perform the equivalent computation as the extracted operation, and replacing the extracted operation with the selected formula. The formula can be selected randomly or deterministically. The extracted operation can be an arithmetic operation or a Boolean operation. | 08-16-2012 |
20120222004 | PUBLISHING AND UPDATING OF MULTIDIMENSIONAL MODELS USING ORCHESTRATION TOOLS FOR SOFTWARE OFFERINGS - The disclosed embodiments provide a system that facilitates the maintenance and execution of a software offering. During operation, the system obtains model data associated with a multidimensional model of the software offering. Next, the system publishes the model data in a set of orchestration tools for the software offering, wherein the model data enables use of the multidimensional model in managing the execution of the software offering from the orchestration tools. | 08-30-2012 |
20120222005 | OFF-HEAP DIRECT-MEMORY DATA STORES, METHODS OF CREATING AND/OR MANAGING OFF-HEAP DIRECT-MEMORY DATA STORES, AND/OR SYSTEMS INCLUDING OFF-HEAP DIRECT-MEMORY DATA STORE - Certain example embodiments relate to a highly-concurrent, predictable, fast, self-managed, in-process space for storing data that is hidden away from the garbage collector and its related pauses. More particularly, certain example embodiments relate to improved memory management techniques for computer systems that leverage an off-heap direct-memory data store that is massively scalable and highly efficient. The off-heap store may be provided in connection with a Java-based environment, and garbage collection may be completely or nearly completely avoided for the off-heap store. The off-heap store may be integrated into a tiered storage solution in certain example embodiments. | 08-30-2012 |
20120222006 | DETECTING PLUG-IN AND FRAGMENT ISSUES WITH SOFTWARE PRODUCTS - Detection of various issues with plug-ins and fragments corresponding to a software product as part of an automated quality engineering investigation is provided. In order to determine whether any issues are present, information pertaining to each plug-in and fragment is analyzed. The information can be stored in a corresponding manifest for the plug-in and fragment, and can include version information and dependency information for the corresponding plug-in and fragment. The issues can include an error relating to the manifest, an error relating to the version information, an error relating to the dependency information, and/or the like. | 08-30-2012 |
20120227030 | SYSTEMS AND METHODS FOR MANAGING VERSIONS OF SOFTWARE PACKAGES - Embodiments relate to systems and methods for managing versions of a software package in a development environment. A package distribution module can interface with a set of stages of the development environment to manage the development of multiple versions of software packages. The package distribution module can establish access rights of entities to advance appropriate versions of the software packages to appropriate stages of the development environment. One or more versions of the software packages can be advanced or moved to other stages of the development environment according to the access rights. The package distribution module can establish new access parameters of software packages in response to the one or more versions advancing or moving to other stages, such that appropriate entities have access to advance appropriate versions. The package distribution module can provide production versions of software packages to a package manager for distribution to target machines. | 09-06-2012 |
20120227031 | MANAGING DYNAMIC CONFIGURATION DATA - Data for a dynamic configuration of a set of producer components is stored in a set of component objects and a set of relationship objects. When an event is received indicating a change to the dynamic configuration, a component object and/or relationship object is updated to reflect the change. The component and/or relationship object(s) can be used to notify one or more listening components of modifications to the dynamic configuration. In this manner, listening components are only loosely coupled with producer components making any necessary adjustments to configuration changes easier to implement. | 09-06-2012 |
20120233593 | Managed Enterprise Software Components as Dynamic Services - A computer-implemented method, system, and medium is disclosed for implementing a hybrid application server. The server is configured to determine that a bundle deployed onto a dynamic module system defines a component that is manageable by an application server component container. In response to the determining, the application server deploys the component onto the component container and creates an instance of the component in the container so that the container can manage the component. Finally, the application server registers a proxy handle to the component as a service in the dynamic module system. Thereafter, the proxy handle is discoverable and invocable by another component. | 09-13-2012 |
20120233594 | SHARABLE DEVELOPMENT ENVIRONMENT BOOKMARKS FOR FUNCTIONAL/DATA FLOW - An embodiment of the invention provides relative bookmarks that are sharable between developers engaged in product development utilizing integrated design environment applications. The relative bookmarks are sharable in that they can be exported, imported, activated and deactivated. The relative bookmarks are relative in that they do not rely on the original code line and contain at least function and/or data flow information, facilitating quick identification of relevant lines of code that have been previously bookmarked. The relative bookmarks can also be utilized to insert breakpoints. | 09-13-2012 |
20120246615 | COMPLETE AND COMPATIBLE FUNCTION - An arrangement for verifying the completeness and compatibility of software components in an electronic control unit includes a bootloader and a CompleteCompatible verification component. The bootloader is arranged to, upon start-up of the electronic control unit, verify the completeness and compatibility of the CompleteCompatible verification component, and upon such verification being positive initiate the CompleteCompatible verification component. The CompleteCompatible verification component is arranged to, upon performance thereof, verify the completeness and compatibility of further software components in the electronic control unit. | 09-27-2012 |
20120254834 | MELDING OF MEDIATION FLOW SERVICE COMPONENT ARCHITECTURE (SCA) COMPONENTS - Embodiments of the present invention provide a method, system and computer program product for melding mediation and adaptation modules of a service component architecture (SCA) system. A method for melding mediation and adaptation modules of an SCA system can include selecting each of a mediation module and an adaptation module in an integrated development tool executing in memory by a processor of a computer and loading respectively different descriptor files for each of the mediation module and the adaptation module. The method further can include combining descriptors from the different descriptor files into a single descriptor file for a melded module. Finally, the method can include modifying names and wiring descriptors in the single descriptor file for the melded module to account for a combination of the mediation component and the adaptation component in the melded component. | 10-04-2012 |
20120272214 | INTERFACE METHOD RESOLUTION FOR VIRTUAL EXTENSION METHODS - The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system obtains, from the software program, a method call associated with one or more interfaces containing a virtual extension method. Next, the system resolves the method call by obtaining a method implementation corresponding to the method call from at least one of an inheritance hierarchy associated with the method call and the virtual extension method. | 10-25-2012 |
20120284690 | VALIDATING THE CONFIGURATION OF DISTRIBUTED SYSTEMS - The present invention extends to methods, systems, and computer program products for validations the configuration of distributed systems. Validation can include a collection of utilities that are systematically deployed across the nodes of an appliance. The utilities execute specified tasks, that when completed, validate the proper functioning state of hardware and/or software components of the appliance. The utilities generate logs, which can be aggregated to present a global view of the appliance. | 11-08-2012 |
20120284691 | SOFTWARE ANALYSIS SYSTEM AND METHOD OF USE - A system and a method for determining at least one software signature, comprising: performing process associated with obtaining a software program in a form of a sequence of instructions (SOI) of the software program; and performing processing associated with generating a signature for the software program where the signature comprises a ratio of a set of SOI counts over total SOI counts of the software program. | 11-08-2012 |
20120291012 | MANAGING A WORKING SET IN AN INTEGRATED DEVELOPMENT ENVIRONMENT - Files supporting a development activity in an IDE are previewed and are not added to a collection of files in a working set for the development activity. A previewed file is represented by a single preview tab displayed on the user interface. The content of a previewed file can be displayed in a preview display portion of a user interface. The preview tab can be stylistically distinct from a durable tab and can identify the current previewed file. A previewed file can be promoted to a durable file. A promoted previewed file is added to the working set for the development activity. | 11-15-2012 |
20120304151 | REALTIME TRACKING OF SOFTWARE COMPONENTS - The disclosure is for run-time accessing a software component is provided, together with a computer system embodying the same, and a software utility directing the method. Initially a software component is loaded and analysed to identify one or more features thereof, which features are checked against a database. Following the check, the component is classified as one of at least first, second, and third component types. A first component type is run without amendment. A second component type is replaced by a component of equivalent functionality prior to running. A third component type is blocked from running. | 11-29-2012 |
20120304152 | REALTIME TRACKING OF SOFTWARE COMPONENTS - The disclosure is for run-time accessing a software component is provided, together with a computer system embodying the same, and a software utility directing the method. Initially a software component is loaded and analysed to identify one or more features thereof, which features are checked against a database. Following the check, the component is classified as one of at least first, second, and third component types. A first component type is run without amendment. A second component type is replaced by a component of equivalent functionality prior to running. A third component type is blocked from running. | 11-29-2012 |
20120311534 | SYSTEM AND METHOD FOR RECOMMENDING SOFTWARE ARTIFACTS - A system and method are discussed that relate to recommending one or more software artifacts to an artifact user. Characteristic information about the artifact user and about a desired artifact is obtained. First metadata about each of one or more candidate artifacts is retrieved. A score is assigned to each of the one or more candidate artifacts, based on a first evaluation of one or more predetermined criteria applied to the retrieved first metadata. The scored artifacts are scaled based on a second evaluation of each of the one or more scored artifacts, the scaling being in view of the characteristic information about the artifact user and the characteristic information about the desired artifact. Finally, one or more scaled artifacts are recommended to the artifact user based on the second evaluation applied to each of the one or more scored artifacts, that is based on the scaled scores. | 12-06-2012 |
20120317546 | METHOD AND SYSTEM FOR CHECKING THE CONSISTENCY OF APPLICATION JAR FILES - A computer method and system dynamically provide consistency of Java application files. A processor executed routine is configured (e.g., instrumented as an agent) to intercept each class that is loaded into a subject Java application or JVM. The system computes a cyclic redundancy check (CRC) of the respective JAR file surrounding the loaded class. The system compares the computed CRC value to a CRC value of at least one other copy of the respective JAR file. Based on the comparison, the system determines consistency (e.g., same version) of the multiple copies of the respective JAR file used by the subject Java application. If the multiple copies of the respective JAR file are determined to be inconsistent, the system alerts the user and/or enables the application to abort. | 12-13-2012 |
20120331447 | ADAPTIVE CHANGE MANAGEMENT IN COMPUTER SYSTEM LANDSCAPES - An adaptive automatic change management for computer system landscapes is described herein. A predefined set of attributes are extracted or obtained for a computer system artifact, together with a number of values assigned to the set of attributes. A unique identification section is created and distributed among the computer systems in the landscape based on the set of attributes and the assigned values, where the unique identification section encompass computer system artifacts of a same kind. A modification of an artifact of the same kind is tracked at a computer system. The tracked modification is automatically applied in the computer system to one or more incoming computer system artifacts of the same kind. | 12-27-2012 |
20130007704 | CODE REVIEWER SELECTION IN A DISTRIBUTED SOFTWARE DEVELOPMENT ENVIRONMENT - Embodiments of the present provide a method, system and computer program product for reviewer selection during distributed software development. In an embodiment of the invention, a method for reviewer selection during distributed software development can include receiving a request to review a module of source code stored in a source code repository and managed by an IDE executing in memory of a computer. The method also can include retrieving meta-data for the module of source code referencing different collaborators previously accessing the module of source code in the IDE. The method yet further can include ranking the collaborators according to at least one user centric characteristic of the module of source code. Finally, the method can include selecting a highest ranked one of the collaborators to review the module of source code. | 01-03-2013 |
20130007705 | SYSTEM, METHOD AND COMPUTER PROGRAM PRODUCT FOR PREDICTING ITEM PREFERENCE USING REVENUE-WEIGHTED COLLABORATIVE FILTER - Embodiments disclosed provide a system, method, and computer program product for identifying consumer items more likely to be bought by an individual user. In some embodiments, a collaborative filter may be used to rank items based on the degree to which they match user preferences. The collaborative filter may be hierarchical and may take various factors into consideration. Example factors may include the similarity among items based on observable features, a summary of aggregate online search behavior across multiple users, the item features determined to be most important to the individual user, and a baseline item against which a conditional probability of another item being selected is measured. | 01-03-2013 |
20130007706 | BUILDING OPTIMIZED DOWNLOAD MODULES LEVERAGING MODULARIZED DEPENDENCIES - Embodiments relate to building a downloadable application. In response to a request to build a downloadable application, a build system determines a set of resources used by the downloadable application. The build system reads this initial set of resources to discover other resources used by the downloadable application. The build system determines resource dependencies for the set of resources and the discovered set of resources, and creates a dependency data structure according to the resource dependencies. Using the dependency data structure, the build system determines a subset of the set of resources and the discovered set of resources to include in a module associated with the downloadable application. | 01-03-2013 |
20130007707 | Using the Z/OS Load Module System Status Index to Distinguish Product Tag Files - A method, system, and computer-usable medium are disclosed for managing software product information in a z/OS environment. Product information associated with a software product is determined and then processed to generate product tag information. A System Status Index (SSI) attribute is generated with a unique identifier signifying that the SSI attribute comprises SSI product tag information. The SSI product tag information is then associated with the SSI attribute with the unique identifier. The z/OS environment is then scanned for SSI attributes. Those SSI attributes comprising a unique identifier are processed to read their associated SSI product tag information. The product tag information is then processed to generate software product information, which is then stored in a repository of software product information. | 01-03-2013 |
20130007708 | INFORMATION PROCESSING DEVICE, INFORMATION PROCESSING METHOD, AND INFORMATION PROCESSING PROGRAM - An objective of the disclosed invention is to derive a more apt similarity by taking into account all components up to and including lower order components that are included in a model. The disclosed invention also allows carrying out more efficient information system building. | 01-03-2013 |
20130024840 | Handwriting images onto an internet supported webpage in real time - The ability to handwrite documents onto a website in real time inherently is intended to by synonymous with the ability to handwrite any image onto an Internet supported webpage in real time. The software that will support this online handwriting technology is called the Web Based Writing System (WBWS). The hardware required to support this technology is an Internet capable device which may be accessorized with a digital writing pad and stylus, a mouse or even existing handwriting software (software understood to not currently be web compatible). A description of the WBWS is listed in the claims section of this application. | 01-24-2013 |
20130031530 | CREATION AND MANAGEMENT OF ELECTRONIC FILES FOR A LOCALIZATION PROJECT - Electronic files for a localization project may be created and/or managed. The electronic files may be based on a data structure that defines the format and content of the electronic files and may include a first data structure portion that may contain data representing a plurality of references to localization project files. The data structure may includes a second data structure portion that may be associated with the first data structure portion that may contain data that may represent a plurality of references to standard files. | 01-31-2013 |
20130042220 | AUTOMATIC GENERATION OF USER STORIES FOR SOFTWARE PRODUCTS VIA A PRODUCT CONTENT SPACE - Exemplary embodiments include a computer-implemented method for generating agile user stories, the method including collecting, by a processor, a plurality of requirements, creating, by the processor, a plurality of content space specification files that includes the plurality of requirements, processing, by the processor, the plurality of content space specification files to generate the user stories and outputting, by the processor, the user stories. | 02-14-2013 |
20130047135 | ENTERPRISE COMPUTING PLATFORM - Various technologies related to an enterprise computing platform are presented. A new level of software development can be achieved by avoiding the coding process. An enterprise computing platform having a variety of frameworks can be configured to operate in a variety of business domains. Features such as parallel computing, distributed computing, logical documents, document transformation, space visualization, data security, and others can be accomplished via configuration rather than coding. Considerable efficiency improvements in the software development process can be realized. | 02-21-2013 |
20130055202 | IDENTIFYING COMPONENTS OF A BUNDLED SOFTWARE PRODUCT - A method for identifying software components of a software product comprises establishing, by a computer, data representative of at least one of an attribute and an action of at least one of a first software component in a computer system and a second software component in the computer system, establishing a first confidence value indicative of a likelihood that the first software component belongs to the software product, establishing, based on the data, a second confidence value indicative of a likelihood that the first software component and the second software component are software components of a common software product, and establishing, based on the first and second confidence values, a third confidence value indicative of a likelihood that the second software component belongs to the software product. | 02-28-2013 |
20130080996 | SOFTWARE COMPONENT PLACEMENT ON EXECUTION PLATFORMS - A method, system, and computer program product for improving software component placement on software execution platforms are provided in the illustrative embodiments. A computer determines whether a code corresponding to the software component includes business process logic. The computer determines a granularity level of the code. The granularity level of the code is a categorization of the code according to whether a number of external references in the code exceed a threshold value. The computer, responsive to determining the granularity level of the code, recommends placement of a first portion of the code on a first platform in the set of software execution platforms. | 03-28-2013 |
20130091488 | Selection and Assessment of Software Components - The present disclosure involves systems, software, and computer implemented methods for providing selection and assessment of software components. One process includes operations for identifying a software component for assessment. Dependencies associated with the software component are analyzed, wherein analyzing dependencies includes identifying at least one relevant perspective associated with the software component, identifying a scope associated with the at least one relevant perspective, and determining whether the software component is associated with at least one related infrastructure component based on the scope or at least one other software component that the software component depends on based on the scope. The software component and each of the at least one related infrastructure component or the at least one other software component are assessed against a set of criteria. | 04-11-2013 |
20130104104 | SYSTEM AND METHOD FOR REFACTORING A BLOCK OF SOFTWARE - A system for refactoring a block of software may include an analyzer for receiving a set of workflows via a user interface and configured to analyze each of the workflows one at a time to determine a set of refactoring opportunity, the user interface configured to transfer the set of workflows from a user to the analyzer and to transfer a set of refactoring opportunity from the analyzer to said user after said analysis of said set of workflows. The system also includes set of refactoring opportunity into a step-wise arrangement of implementation of said set of refactoring opportunity on said block of software, an implementation device for implementing said set of refactoring opportunity on said block of software to produce a refactored block of software and over a design associated to said block of software to produce a refactored design associated to said refactored block of software. | 04-25-2013 |
20130111438 | Software Maintenance Supporting Device and Electronic Control Device Verified by the Same | 05-02-2013 |
20130145348 | UNIVERSAL AND ADAPTIVE SOFTWARE DEVELOPMENT PLATFORM FOR DATA-DRIVEN APPLICATIONS - A software application platform that abstracts a computing platform, a database layer, and a rendering medium is disclosed. A platform-independent application programming interface is disclosed, as well as an abstract database layer. The abstraction of the database layer comprises two sub-layers, including a layer having a uniform interface that treats data records as plain objects and a layer having constructs that facilitate the automated generation of user interfaces for data record navigation and management. Further, a software application platform that is independent of rendering medium is disclosed. | 06-06-2013 |
20130152044 | Software Quality Evaluating System And Methods For Determining An Extent Of Software Code Changes - A method for determining an extent of code changes upon implementation of a software modification has the steps of: registering the number of software code components and the respective number of lines of code of each software component of a software code before the implementation of the software modification, implementing the software modification by changing the software code, determining the number of software code components that have changed due to the implementation of the software modification, determining the number of lines of code of each software component that have changed due to the implementation of the software modification, and determining an invasiveness value on the basis of the determined number of software code components that have changed and determined number of lines of code that have changed, the invasiveness value being indicative of the extent of software code changes upon implementation of the software modification. | 06-13-2013 |
20130152045 | SOFTWARE INTERNATIONALIZATION ESTIMATION MODEL - Various technologies related to estimating programming effort to internationalize a software program are described. A sampling technique can be applied to the numerous program files that make up the software program. Stratification by impact point type can be supported. Historical data can be used to provide an accurate and reliable estimate without having to completely analyze all files in the software program. | 06-13-2013 |
20130159971 | PROCESSING CHANGED APPLICATION METADATA BASED ON RELEVANCE - A system includes execution of a software application based on metadata defining a first plurality of software components, reception of second metadata defining the first plurality of software components, determination, based on the second metadata, of a second plurality of the first plurality of software components for which the second metadata is different from the first metadata, and for which the second metadata is associated with elements of the software application, and generation of the elements of the software application based on the second metadata of the second plurality of software components. | 06-20-2013 |
20130159972 | IDENTIFYING COMPONENTS OF A BUNDLED SOFTWARE PRODUCT - A method for identifying software components of a software product comprises establishing, by a computer, data representative of at least one of an attribute and an action of at least one of a first software component in a computer system and a second software component in the computer system, establishing a first confidence value indicative of a likelihood that the first software component belongs to the software product, establishing, based on the data, a second confidence value indicative of a likelihood that the first software component and the second software component are software components of a common software product, and establishing, based on the first and second confidence values, a third confidence value indicative of a likelihood that the second software component belongs to the software product. | 06-20-2013 |
20130167113 | MAINTENANCE OF A SUBROUTINE REPOSITORY FOR AN APPLICATION UNDER TEST BASED ON SUBROUTINE USAGE INFORMATION - Embodiments of the invention relate to maintaining a repository of subroutines used by a software program under test based on an analysis of subroutine usage logs. One aspect of the invention concerns a system for analyzing a log of subroutine usage by an application under test to identify subroutines used by the application based on actions in the subroutines, and comparing the identified subroutines against a repository of subroutines applicable to the application. The system may further designate a subroutine in the repository as a matching subroutine, modify or delete a subroutine, or add a new subroutine to the repository. | 06-27-2013 |
20130167114 | CODE SCORING - Methods and apparatus, including computer program products, are provided for code scoring. In one aspect, there is provided a computer-implemented method. The method may include receiving metadata including information representative of at least one custom code module used in a business system; receiving at least one rule from a rules template; and calculating, based on the received metadata and the received at least one rule, a score representative of whether the at least one custom code module is maintained. Related apparatus, systems, methods, and articles are also described. | 06-27-2013 |
20130167115 | Computing Reusability Index of Software Assets - A method and a system for computing a reusability index of a software asset are provided. The system comprises a processor and a memory coupled to the processor. The memory comprises a characteristics module, a dimensions module, and a reusability module. The characteristics module is configured to receive a characteristic score for each of a plurality of predefined characteristics associated with the software asset. The dimensions module is configured to determine, based on the characteristic score weighted according to a characteristic weighing criterion, a dimension score for each of a plurality of predefined dimensions, wherein each of the plurality of predefined dimensions comprises at least one of the plurality of predefined characteristics. The reusability module is configured to compute, based on the dimension score weighted according to a dimension weighing criterion, the reusability index of the software asset. | 06-27-2013 |
20130167116 | MAINTENANCE OF A SUBROUTINE REPOSITORY FOR AN APPLICATION UNDER TEST BASED ON SUBROUTINE USAGE INFORMATION - Embodiments of the invention relate to maintaining a repository of subroutines used by a software program under test based on an analysis of subroutine usage logs. One aspect of the invention concerns a method that comprises analyzing a log of subroutine usage by an application under test to identify subroutines used by the application based on actions in the subroutines, and comparing the identified subroutines against a repository of subroutines applicable to the application. The method may further designate a subroutine in the repository as a matching subroutine, modify or delete a subroutine, or add a new subroutine to the repository. | 06-27-2013 |
20130174121 | Automated Run Time Embedding of Software Snippets (ARTESS) system and method for improving the software and the software testing. - The Automated Run Time Embedding of Software Snippets (ARTESS) system and method comprise of a pick-and-choose multi-phase integrated process for automated profiling and execution of software modules in test environment for the purpose of verification of the software functional stability throughout the software life cycle. Additionally, ARTESS method and system are suitable for upgrade, in automated way, of application-specific software modules with improvements to error-handling code. The presented ARTESS method is deployable for software systems constructed in languages that allow run-time source code modifications. | 07-04-2013 |
20130179861 | BUILDING OPTIMIZED DOWNLOAD MODULES LEVERAGING MODULARIZED DEPENDENCIES - Embodiments relate to building a downloadable application. In response to a request to build a downloadable application, a build system determines a set of resources used by the downloadable application. The build system reads this initial set of resources to discover other resources used by the downloadable application. The build system determines resource dependencies for the set of resources and the discovered set of resources, and creates a dependency data. structure according to the resource dependencies. Using the dependency data structure, the build system determines a subset of the set of resources and the discovered set of resources to include in a module associated with the downloadable application. | 07-11-2013 |
20130185700 | Tracking Stale Comments in Source Code Listings - Managing comments within computer software source code by detecting a change in a portion of computer software source code, identifying a comment that is associated with the portion, and providing an indication that the comment was not changed subsequent to the portion being changed. | 07-18-2013 |
20130185701 | CENTRALIZED, OBJECT-LEVEL CHANGE TRACKING - An update handler may determine object change data characterizing changes made to software objects. A change data manager store the object change data in a tracking database in conjunction with an object identifier for each changed software object. A query handler may receive an object-specific query requesting a subset of the object change data, and a response generator may provide the subset of the object change data from the tracking database, based on the corresponding object identifiers. | 07-18-2013 |
20130198715 | Selective application view - A selective outline view is described in an application development environment that allows viewing an outline of an application in either a procedural code outline view or a declarative tree-view. The application is written, at least in part, in a tag-based declarative language. The declarative language has a representational relationship to a procedural language that defines the logic of application. The choice of views is presented in a selection indicator. On selection of the procedural code outline view, the application is processed to obtain a procedural code representation of the application using the relationship between the declarative and procedural languages. The procedural code outline view is generated from the procedural code representation. On selection of the declarative tree-view of the application, the ADE parses the application to obtain a declarative object model of the application. The declarative tree-view of the application is created using the declarative object model. | 08-01-2013 |
20130212562 | SYSTEM AND METHOD OF PROVIDING REAL-TIME UPDATES RELATED TO IN-USE ARTIFACTS IN A SOFTWARE DEVELOPMENT ENVIRONMENT - An artifact update notification system that includes a server computer and client computer is discussed and described. The server computer stores artifact preferences, determined according to objective and subjective criteria, of artifact characteristics. The client computer executes a software development environment that makes use of a software artifact. The server computer and client computer interact to perform an update cycle. The update cycle includes the server computer communicating to the client computer whether there is an actionable change to the software artifact with respect to the artifact preferences. If there has been an actionable change to the software artifact, the client computer performs an update action in the software development environment in response to the actionable change. A related artifact update notification method is also described, as is a computer-readable storage medium that includes instructions for operation of a computer to execute a related artifact update notification method. | 08-15-2013 |
20130219358 | SYSTEM AND METHOD FOR AUTOMATICALLY DETERMINING RELATIONSHIPS BETWEEN SOFTWARE ARTIFACTS USING MULTIPLE EVIDENCE SOURCES - A method (which can be computer implemented) for inferring whether at least a first relationship exists between at least first and second entities includes the steps of applying a first assessor to obtain a first confidence level pertaining to putative existence of said at least first relationship between said at least first and second entities, applying a second assessor to obtain a second confidence level pertaining to putative existence of said at least first relationship between said at least first and second entities, and combining said first and second confidence levels to obtain an overall inference whether said at least first relationship exists between said at least first and second entities. | 08-22-2013 |
20130219359 | PROCESS EVALUATION DEVICE, PROGRAM AND METHOD - A process evaluation device, comprising: a development process definition storage unit which stores definition information on a plurality of processes for developing software and sequence numbers thereof; a transition information acquiring unit which acquires identification information or a sequence number of a new process after a backward transition occurs, wherein a process transition from a certain process referred hereafter as an evaluation origin to said new process is said backward transition when a sequence number of said new process is smaller than a sequence number of said evaluation and a transition information analysis unit which calculates and thereby outputs a backing-away distance which is a difference between a sequence number of said evaluation origin and a sequence number of said new process, is provided, in order to apprehend what are real causes of the development delay. | 08-22-2013 |
20130227522 | Integrated Application Localization - Integrated application localization techniques are described in which support for application localization is provided as an integrated component of a development environment. Localizations for selected languages/locales integrate with application builds in the development environment so that updates are synchronized with project resources for multiple languages. This involves creating and employing localization files corresponding to source content of a project using a designated file format suitable to enable translations. Localization files that are created in the designated format may be exposed in various ways for translation via the system, a developer, a translation service, or other selected translation sources. A single multilingual resource file for an application is then generated to contain resources in multiple languages based on translations made available through the translation sources. | 08-29-2013 |
20130227523 | Software-Developing Structured-Data-File Creating Apparatus and Method Capable of Efficiently Creating Data File Used in Developing Program for Device - A software-developing structured-data-file creating apparatus of the present disclosure includes a storage unit configured to store a specification list comprising specific values associated with a plurality of individual items indicative of specifications of a device and a location-path list comprising location paths associated with individual portions of the plurality of individual items. The software-developing structured-data-file creating apparatus also includes an input unit, configured to associate common portions of the location paths. The software-developing structured-data-file creating apparatus additionally includes a structured-data-file creating unit configured to create a data file comprising the common portions of the location paths in the location-path. The corresponding values in the specification list are added to the individual location paths. | 08-29-2013 |
20130239089 | SYSTEMS AND METHODS FOR COMPUTING APPLICATIONS - Systems and methods for dynamic development and deployment of computing applications including a development framework, a visual design subsystem, and a deployment subsystem, where at runtime the deployment subsystem is operable to dynamically deploy a computing application realized by a blueprint by sending a request at runtime for graphs and components instantiated by the blueprint. | 09-12-2013 |
20130247004 | VISUALLY INDICATING FILE ALLOCATION IN AN INTEGRATED DEVELOPMENT ENVIRONMENT - In a method for allocating a file to a user, a first computer receives, over a network, data monitored by a second computer. The first computer comprises an IDE client. The data comprises data of usage of the file by one or more users in a group of users. The first computer receives a request to allocate the file to a first user in the group. In response to the first computer determining that, based on the data of usage, the file is allocated to a second user in the group, the first computer denies the request. The first computer adds the first user to an end of a queue identifying one or more users in the group that are waiting for the second user to relinquish allocation of the file. The first computer utilizes the data of usage to display the queue in the IDE client. | 09-19-2013 |
20130254742 | Software Portfolio Management Based on Feature Usage - An approach is provided to gather items of usage data that pertain a number of instrumented software modules that are included in a software offering. The usage data is gathered from a number of customer installations of the software offering. Usage statistics are computed for the software modules and are used to determine support levels for the instrumented software modules. In another aspect, an approach is provided that detects execution of the software modules included in a software offering. Usage statistics are recorded in a local data store. One of the usage statistics is a module identifier that the software module that was executed. In addition, the usage statistics track the number of times each of the software modules was executed. The usage statistics are periodically transmitting a computer network to a software provider that develops and maintains the software offering. | 09-26-2013 |
20130268913 | MANAGING APPLICATION TEMPLATE ARTIFACTS IN A NETWORKED COMPUTING ENVIRONMENT - Embodiments of the present invention provide an approach for managing application template artifacts throughout an application's lifecycle in a networked computing environment (e.g., a cloud computing environment). In a typical embodiment, a workload template is assigned to each phase of a set of successive phases of the application's lifecycle. Each template typically refers to a template in a preceding phase of the lifecycle. Moreover, the templates may contain pointers to artifacts used in the phases assigned thereto. Any changes occurring in the artifacts/phases are propagated to the corresponding templates so as to automatically manage application lifecycle operations. | 10-10-2013 |
20130268914 | SERVICE LEVEL OBJECTIVE FOR CLOUD HOSTED APPLICATIONS - Embodiments are directed to declaratively managing software applications, dynamically applying configuration changes to a specified software application based on a service level objective (SLO) and to efficiently performing an impact analysis for a specified service level agreement SLO. | 10-10-2013 |
20130311971 | Method and Apparatus for Programming Software Components - Methods and systems are disclosed for programming software components that treats software components as the basic unit of abstraction and computation. A software component is encapsulated and classes and other program entities, such as data fields and methods, within a given component do not exist beyond a component boundary. A component interacts with other components only by means of a defined set of input and output ports. A component can inherit and implement ports declared in a template and can declare and implement new ports. A component can only access the external environment through its output ports. An output port of one component can only be connected to a conforming input port of another component. A connect statement is an explicit plumbing operation for connecting components together. Interactions between components are loosely coupled. A related set of templates can be grouped to form a group. | 11-21-2013 |
20130318496 | DETECTION OF CENTRAL-REGISTRY EVENTS INFLUENCING DYNAMIC POINTERS AND APP FEATURE DEPENDENCIES - A first feature (e.g., chart or table) includes a reference to a dynamic pointer. Independently, the pointer is defined to point to a second feature (e.g., a query). The first feature is automatically updated to reflect a current value of the second feature. The reference to the pointer and pointer definition are recorded in a central registry, and changes to the pointer or second feature automatically cause the first feature to be updated to reflect the change. A mapping between features can be generated using the registry and can identify interrelationships to a developer. Further, changes in the registry can be tracked, such that a developer can view changes pertaining to a particular time period and/or feature of interest (e.g., corresponding to an operation problem). | 11-28-2013 |
20130326476 | COMPONENT ANALYSIS OF SOFTWARE APPLICATIONS ON COMPUTING DEVICES - Detection, identification, and control of application behavior dealing with malware, security risks, data privacy, or resource usage can be difficult in an era of complex, composite software applications composed of multiple components. Software applications are analyzed to determine their components and to identify the behaviors associated with each of the components. Components can also be analyzed with respect to similarity of previously known components. Behaviors can include use of personal identifying information or device information, or any actions that can be taken by applications on the device, including user interface displays, notifications, network communications, and file reading or writing actions. Policies to control or restrict the behavior of applications and their components may be defined and applied. In one embodiment this can include the identification of advertising networks and defining policies to permit various opt-out actions for these advertising networks. | 12-05-2013 |
20130326477 | EXPRESSING INTENT TO CONTROL BEHAVIOR OF APPLICATION COMPONENTS - Detection, identification, and control of application behavior dealing with malware, security risks, data privacy, or resource usage can be difficult in an era of complex, composite software applications composed of multiple components. Software applications are analyzed to determine their components and to identify the behaviors associated with each of the components. Components can also be analyzed with respect to similarity of previously known components. Behaviors can include use of personal identifying information or device information, or any actions that can be taken by applications on the device, including user interface displays, notifications, network communications, and file reading or writing actions. Policies to control or restrict the behavior of applications and their components may be defined and applied. In one embodiment this can include the identification of advertising networks and defining policies to permit various opt-out actions for these advertising networks. | 12-05-2013 |
20130339927 | Communications Platform Supporting Stateless Application Development - An apparatus for supporting development of software applications has been developed. The invention includes, multiple endpoints that interact with a user of a communications platform and a session manager (SM) that establishes and terminates a session with the endpoint. The invention has a session bridge (SB) that is a communication pathway between multiple endpoints and a session router (SR) that controls distribution of session request generated by the endpoint. | 12-19-2013 |
20130346944 | Custom Code Management - A system, method and computer readable medium to remotely control performance of a method including detecting an identifier of an object requested to run on a computer system via a kernel running on the computer system, comparing the identifier with a list of identifiers of custom created code objects, and taking an action as a function of whether or not the identifier of the requested object is on the list of identifiers of custom created code objects. | 12-26-2013 |
20140013300 | PLATFORM FOR DEVELOPMENT AND DEPLOYMENT OF SYSTEM ADMINISTRATION SOLUTIONS - General-purpose components are selectively included in a toolkit hosted by hosting provider computing devices. The general-purpose components are software components. The general-purpose components in the toolkit are available over a computer network to end user computing devices. The end user computing devices utilizes general-purpose components in the toolkit to provide system administration solutions. The system administration solutions are web applications hosted by the hosting provider computing devices. The system administration solutions provide an ability to perform administration tasks on on-premises computer systems of the end users. A hosting provider computing device is configured such that the end user computing devices are able to utilize the general-purpose components in the toolkit on a Software-as-a-Service (SaaS) basis. | 01-09-2014 |
20140013301 | Resource Processing Using an Intermediary for Context-Based Customization of Interaction Deliverables - A software application includes work order resources, each of which defines an atomic operation for the software application, and a construction service resource, which processes the work order resources in response to all interaction requests for the software application. Each interaction request is received from a client and identifies a corresponding work order, which the construction service processes to dynamically construct a set of deliverables, which can include a custom representation of the work order. While processing the interaction request, the construction service, as directed by the work order, can make one or more requests to context resources for context information corresponding to an activity for which the interaction was requested to construct the set of deliverables. The work order resource can comprise a reflective program that enables the construction service to dynamically determine and construct the set of deliverables, including the next appropriate interaction(s) using the context information, thereby directing a set of atomic operations as part of an activity being performed and enabling the dynamic context-based construction of interaction deliverables. | 01-09-2014 |
20140026116 | SOURCE CONTROL EXECUTION PATH LOCKING - An embodiment of the invention provides a method for source control in a computer program, wherein the computer program includes a plurality of files for execution of a plurality of processes. A revised process that is selected by a user on a graphical user interface is identified, wherein the revised process includes an execution path. A revised portion of a file in the revised process that the user is revising, has revised, and/or is planning on revising is identified. Portions of files that are in the execution path of the revised process are identified. The portions of the files in the execution path of the revised process are locked with a source control processor. The locking disallows revisions (e.g., write and delete operations) to the portions of the files in the execution path of the revised process that are not made by the user. | 01-23-2014 |
20140026117 | Source Control Execution Path Locking - An embodiment of the invention provides a method for source control in a computer program, wherein the computer program includes a plurality of files for execution of a plurality of processes. A revised process that is selected by a user on a graphical user interface is identified, wherein the revised process includes an execution path. A revised portion of a file in the revised process that the user is revising, has revised, and/or is planning on revising is identified. Portions of files that are in the execution path of the revised process are identified. The portions of the files in the execution path of the revised process are locked with a source control processor. The locking disallows revisions (e.g., write and delete operations) to the portions of the files in the execution path of the revised process that are not made by the user. | 01-23-2014 |
20140033170 | SYSTEM AND METHOD OF GENERATING REST2REST SERVICES FROM WADL - A system and method is provided for generating a RESTful communication service which offers REST2REST functionality seamlessly with automatic support for the API agnostic features such as policy enforcement, load balancing, routing, failover, logging, accounting, format conversion (XML2JSON,JSON2XML) etc. Such a system can include one or more applications, executing on one or more application servers. The system can also include a WADL plug-in which generates code for the RESTful communication service from Web Application Description Language files (WADL) which define the service interface and internal templates which define the code logic. The method offers rapid and efficient generation of REST APIs supporting API agnostic features, automatic REST API code generation from WADL files, and translation from WADL to WSDL. | 01-30-2014 |
20140040861 | METADATA DRIVEN SOFTWARE ARCHITECTURE - Embodiments of the present invention provide a metadata-driven software architecture that enables multi-tenant application development. Specifically, an application development architecture is provided including a data table that stores the application-accessible data that maps to all custom objects and their fields, as defined by metadata in objects and fields. Forms, reports, work flows, user access privileges, tenant-specific customizations and business logic, and definitions of underlying data tables and indexes exist as metadata. Application components are generated at runtime using the metadata. | 02-06-2014 |
20140053133 | NAMING ALGORITHM FOR EXTENSION FIELDS IN DE-NORMALIZED VIEWS - An extension naming approach for avoiding naming collisions in de-normalized view on a business object can include accessing a reference field bundle, which includes reference field(s) corresponding to a core business object defined in a core software platform of a software architecture, from a metadata repository. A user can define an extension to the business object based on the core business object, for example via a development environment. The reference field(s) can include a defined path from a node in a peripheral object to a corresponding node in the core business object. A unique and reproducible name for the extension field can be generated based on the reference field, and the extension field with the unique and reproducible name can be added to the business object and to a data model of the peripheral object. | 02-20-2014 |
20140068558 | Displaying Dependent Files for Computer Code in a Tabbed-Application User Interface - A method for indicating a change to a dependent file includes receiving a change to a program file. The method further includes displaying, via a computing device, a first identifier for a first dependent file in a first text style, if the first dependent file is changed based on the change to the program file. The method further includes displaying, via the computing device, a second identifier, in a second text style, for a second dependent file. The program file is dependent on the first and the second dependent files. The first text style indicates the first dependent file has been changed based on the change to the program file. The first text style and the second text style are different styles. | 03-06-2014 |
20140068559 | ANNOTATION-BASED INFRASTRUCTURE FOR AUTOMATICALLY GENERATING "PREDICTABLE" IDS FOR VISUAL COMPONENTS IN A WEB-APPLICATION - A method for generating identifiers for software components is provided. A processing device scans source code for an annotation associated with generating an identifier for an object. The processing device generates, using the annotation, an identifier value for the object. When the object does not have a previously assigned value, the processing device assigns the identifier value to the object. When the object has a previously assigned value, the processing device concatenates the identifier value to the previously assigned value of the object and assigns the concatenated identifier value to the object. The processing device then recursively descends into the sub-object's hierarchy by repeating the steps of scanning, generating, and assigning or concatenating and assigning described above. | 03-06-2014 |
20140068560 | SYSTEMS AND METHODS FOR PARTITIONING COMPUTING APPLICATIONS TO OPTIMIZE DEPLOYMENT RESOURCES - Systems and methods for dynamic partitioning of computing applications that involves partitioning a computing application based on processing requirements and available hardware resources to optimize resource usage and security across multiple platforms, and handle interprocess communications across the platforms. | 03-06-2014 |
20140075412 | SYSTEM AND METHOD FOR ELASTICITY MANAGEMENT OF SERVICES WITH A CLOUD COMPUTING ENVIRONMENT - A system and method for elasticity management of services for use with a cloud computing environment. In accordance with an embodiment, a cloud platform enables provisioning of enterprise software applications within a cloud environment, including packaging enterprise applications as service definition packages (SDP), and instantiating the services using service management engines (SME). In an embodiment, an elasticity manager can be used to determine the health of the services, and to take appropriate actions, including detecting events, issuing alerts and/or notifying the orchestration engine to manage the service lifecycle, e.g., to respond to an increased demand for particular services. | 03-13-2014 |
20140089894 | SEARCHING SOURCE CODE - Searching source code includes receiving a search string, a feature type and details of source code to be searched. The source code is parsed to generate an abstract syntax tree. The abstract syntax tree is indexed using a search structure defining all source code features for which searching is enabled. The search string is searched for the search string of the feature type in the indexed abstract syntax tree using a results structure defining the search outputs to be retrieved. A structured search result based on the output of the searching is provided. The structured search result is stored in the storage device. | 03-27-2014 |
20140096109 | APPLICATION OF BUISINESS PROCESS MANAGEMENT STANDARDS FOR DYNAMIC INFORMATION TECHNOLOGY MANAGEMENT PROCESS AND INTEGRATIONS - Processes and integrations include a method for managing a business process application development lifecycle. The method includes initiating, in a planning stage, requirements for an application based on adding new features to the application or a new application, implementing, in a development stage, a service process node (SPN) as a business process, and managing, in an operations stage, software code representing the application in a production environment. The SPN is configured to encapsulate at least one business service object and generate an interface configured to expose internal processes of the at least one business service object. | 04-03-2014 |
20140096110 | MANAGING A SET OF SOFTWARE MODULES IN A SOFTWARE RUNTIME ENVIRONMENT - A method, system, and/or computer program product manages a set of software modules in a software runtime environment, where the set of software modules has one or more dynamic dependencies and one or more static dependencies. Each software module having a static dependency on another software module in a set of software modules is identified. Each subset of the set of software modules that is interdependent with another subset due to static dependencies between subsets is identified. In response to a change in state of a module in an identified subset, the change in state is applied to all modules in the identified subset. | 04-03-2014 |
20140109046 | SYSTEMS AND METHODS FOR A VOICE- AND GESTURE-CONTROLLED MOBILE APPLICATION DEVELOPMENT AND DEPLOYMENT PLATFORM - Systems and methods for developing, customizing, and deploying mobile device applications through voice and/or gesture interactions 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 use voice and/or gesture interactions 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 the mobile application for various mobile operating systems and generates a configuration file for the mobile application that can be distributed to end users for execution on various mobile devices. 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. | 04-17-2014 |
20140109047 | Mobile Phone Based Software Processing Method and Mobile Phone - A mobile phone based software processing method recording time information of installation of each software program in a mobile phone; updating the latest time information of the software; and when it is detected that the time information of certain software is idle for more than a preset time interval, determining that the software is long-term idle, arranging and displaying a list of long-term idle software being idle for more than a preset time interval, and updating or unloading the long-time idle software automatically according to requirements. | 04-17-2014 |
20140115562 | SYSTEM AND METHOD OF PROVIDING REAL-TIME UPDATES RELATED TO IN-USE ARTIFACTS IN A SOFTWARE DEVELOPMENT ENVIRONMENT - An artifact update system including a server and a client is described. The server stores and updates a preference as to a characteristic of an artifact. The client executes a software development environment using the artifact. The server makes, in view of the preference as to the characteristic of the artifact, an actionable change determination as to whether there is a change in the characteristic of the artifact that reaches a threshold level of significance. The server communicates to the client the actionable change determination. When the actionable change determination is that there is a change in the characteristic of the artifact that reaches the threshold level of significance, the client performs a specific action in the software development environment in response to the actionable change determination. | 04-24-2014 |
20140123105 | MELDING OF MEDIATION FLOW SERVICE COMPONENT ARCHITECTURE (SCA) COMPONENTS - Embodiments of the present invention provide a method, system and computer program product for melding mediation and adaptation modules of a service component architecture (SCA) system. A method for melding mediation and adaptation modules of an SCA system can include selecting each of a mediation module and an adaptation module in an integrated development tool executing in memory by a processor of a computer and loading respectively different descriptor files for each of the mediation module and the adaptation module. The method further can include combining descriptors from the different descriptor files into a single descriptor file for a melded module. Finally, the method can include modifying names and wiring descriptors in the single descriptor file for the melded module to account for a combination of the mediation component and the adaptation component in the melded component. | 05-01-2014 |
20140130012 | 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. | 05-08-2014 |
20140137079 | IN-PLACE DEFINITION OF SOFTWARE EXTENSIONS - Implementations of the present disclosure include methods, systems, and computer-readable storage mediums for providing in-place extensions to an application, including receiving one or more artifacts associated with the application; graphically depicting a representation of at least one artifact of the one or more artifacts on a display, the at least one artifact comprising extension points defined by a developer of the application; receiving first user input indicating a first extension to the at least one artifact, the first extension being associated with an extension point of the one or more extension points and being applied to the representation, the at least one artifact remaining unchanged in view of the first extension being applied to the representation; determining a delta based on the first extension and the at least one artifact; and storing the delta in an extension repository, the delta being usable to extend one or more other artifacts. | 05-15-2014 |
20140143756 | AFFINITY RECOMMENDATION IN SOFTWARE LIFECYCLE MANAGEMENT - Software lifecycle management includes, searching, using a processor, historical development data including prior development tasks for a software system. The searching is performed according to a current development task for the software system. A determination is made as to whether the current development task has an affinity with a selected prior development task implemented within the software system. A recommendation is provided for the current development task based upon the selected prior development task. | 05-22-2014 |
20140157234 | Overriding System Attributes and Function Returns in a Software Subsystem - An approach is provided in which a request is received from a software module to retrieve a value stored in a pre-defined location. Prior to retrieving the value, an override tank is checked for a corresponding override value. When the override tank includes an override value, the override value in the override tank is provided to the software module. When the override tank fails to include a corresponding override value, an actual value is retrieved from a pre-defined storage location and provided to the software module. In one embodiment, the override value is an override system attribute value. In another embodiment, the override value is an override function return value. | 06-05-2014 |
20140165031 | PROGRAM CODE LIBRARY CONSOLIDATION IN AN INTEGRATED DEVELOPMENT ENVIRONMENT - An approach for integrated development environment (IDE)-based program code library consolidation in a networked computing environment (e.g., a cloud computing environment) is provided. Under this approach, it may be determined whether to consolidate a first set of program code libraries in an integrated development environment (IDE). The determination may be based on consolidation criteria applicable to the first set of program code libraries. Based on the determination, the first set of program code libraries may be consolidated based on a set of consolidation preferences and a set of consolidation rules to yield a second set of program code libraries. An ordered list identifying the second set of program code libraries may then be generated. | 06-12-2014 |
20140165032 | PROGRAM CODE LIBRARY SEARCHING AND SELECTION IN A NETWORKED COMPUTING ENVIRONMENT - An approach for integrated development environment (IDE)-based program code library searching and selection in multiple programming languages in a networked computing environment is provided. In a typical embodiment, a search request (e.g., to locate a desired program code library) will be received in an IDE and parsed. The search request generally includes a set of annotations corresponding to at least one of: a primary program code language of the program code library, an alternate program code language of the program code library, or a method pair associated with the program code library. A search of at least one program code library repository will then be conducted based on the set of annotations, and a set of matching results will be generated. The set of matching results may include one or more program code libraries, and may be provided to a device hosting the IDE. | 06-12-2014 |
20140165033 | ON-DEMAND DATABASE SERVICE SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT FOR VALIDATING A DEVELOPED APPLICATION - In accordance with embodiments, there are provided mechanisms and methods for validating a developed application. These mechanisms and methods for providing such validation can enable embodiments to ensure that new versions of developed applications will operate in the same application environment of a previous version. The ability of embodiments to provide such validation may lead to an improved application migration development/runtime framework, etc. | 06-12-2014 |
20140189642 | Native Language IDE Code Assistance - An embodiment of the invention provides a method including receiving input from a user interface, wherein the input includes the name of a code segment in a first language. A database is queried with the name of the code segment in the first language to identify the name of the code segment in a second language different from the first language. The database includes names of code segments in a plurality of languages. The name of the code segment is displayed in the second language and/or the name of the code segment in the first language is replaced with the name of the code segment in the second language. | 07-03-2014 |
20140189643 | METHODS FOR CREATING AND PROVIDING A VIRTUAL ENVIRONMENT AND DEVICES THEREOF - A method, non-transitory computer readable medium, and an environment manager computing device comprises receiving at least one selection of one or more environments from a client computing device. An environment definition document associated with the selected one or more environments are obtained. Next, a virtual environment for the selected one or more environments is created based on the obtained environment definition document. Finally, the created virtual environment is provided to the requesting client computing device. | 07-03-2014 |
20140196009 | MODULE STRUCTURAL ANALYSIS SUPPORTING DEVICE AND PROGRAM - A device supporting the structural analysis of a module comprises: a storage means storing at least one module; and a conversion means that converts a prescribed target module among the modules stored by the storage means to a secondary module and stores same in the storage means. The conversion means reads the target module from the storage means and sequentially outputs to the secondary module each sentence written from a prescribed processing start location in the target module to a prescribed processing end location. The conversion means also recursively develops a sentence written in processing units etc., for execution, and outputs same to the secondary module, when the sentence is a module internal processing unit or a sentence that executes another module. | 07-10-2014 |
20140201710 | SOFTWARE PRODUCT LICENSING BASED ON A CONTENT SPACE - A computer-implemented method for generating software license types, includes collecting, by a processor, a plurality of software product functions, creating, by the processor, a plurality of content space specification files that includes the plurality of software product functions, processing, by the processor, the plurality of content space specification files to generate a plurality of software license types and outputting, by the processor, the plurality of software license types. | 07-17-2014 |
20140201711 | LOGGING AND PROFILING CONTENT SPACE DATA AND COVERAGE METRIC SELF-REPORTING - A computer-implemented method for generating user stories for a software product, includes collecting, by a processor, a plurality of requirements, creating, by the processor, a plurality of content space specification files that includes the plurality of requirements, processing, by the processor, the plurality of content space specification files to generate the user stories that are related to real time data of the software product, defining, by the processor, a content space, mapping, by the processor, the user stories to the content space and embedding, by the processor, the content space with the software product, wherein user stories include at least one of real time log data, profile statistics data, and coverage metric self-reporting data. | 07-17-2014 |
20140208295 | METHOD AND SYSTEM FOR CREATING AND MANAGING A DYNAMIC ROUTE TOPOGRAPHY FOR SERVICE ORIENTED SOFTWARE ENVIRONMENTS - A system, method, and computer-readable medium are provided for managing a route topography in a software environment. The system includes a dashboard user interface for allowing a user to manage the services that are part of a software application. The dashboard allows the user to add and delete services for a software application, to establish a communication identifier of each service, and to clone a first route topography to create a second route topography. A routing service manages the route topography by storing a route identifier and the associated services for the route. When a user modifies an existing route topography or creates a new route topography, the information is managed by the routing service which provides the route information to requesting services upon demand. In one embodiment, each service of the software application includes a route cache with routing information that may be updated periodically by the routing service. | 07-24-2014 |
20140215435 | AUTOMATIC UNTANGLING CYCLIC DEPENDENCIES IN SOFTWARE SYSTEMS - A computerized method, system and computer product for untangling cyclic dependencies between components in software architecture is disclosed. The method includes receiving a software architecture that includes a set of components wherein the components include further elements. The method includes finding one or more cyclic dependencies between the set of components and creating a set of rearranged untangled components. The method includes outputting the rearranged components. | 07-31-2014 |
20140245258 | SYSTEM AND METHOD FOR TRANSPLANTING SOURCE CODE - A computer system for integrating existing source code into target source code, the computer system including a change point mapper that outputs a plurality of suggested candidate mappings between a change point of the existing source code and a plurality of change points of the target source code, a change point transformer that receives the plurality of suggested candidate mappings and outputs an updated existing source code, the change point transformer being configured to automatically update the existing source code based on a selected candidate mapping of the plurality of suggested candidate mappings, and a change point transplanter being configured to insert the updated existing source code into the target source code. | 08-28-2014 |
20140245259 | METHOD FOR SECURING A PROGRAM - A method for securing a first program, the first program including a finite number of program points and evolution rules associated to program points and defining the passage of a program point to another, the method including defining a plurality of exit cases and, when a second program is used in the definition of the first program, for each exit case, definition of a branching toward a specific program point of the first program or a declaration of branching impossibility, defining a set of properties to be proven, each associated with one of the constitutive elements of the first program, said set of properties comprising the branching impossibility as a particular property and establishment of the formal proof of the set of properties. | 08-28-2014 |
20140245260 | DISTRIBUTED IMPLEMENTATION OF SEQUENTIAL CODE THAT INCLUDES A FUTURE - A distributed code including a plurality of programs is created based on a sequential code that includes at least one call of a first function associated with a future, where at least a first of the plurality of programs is to execute the first function associated with the future, and at least a second of the plurality of programs is to execute a second function in a present section of the sequential code. A normalization function is included in each of the plurality of programs to normalize virtual addresses accessed by the first and second functions. | 08-28-2014 |
20140245261 | SYSTEMS AND METHODS FOR COMPUTING APPLICATIONS - Systems and methods for dynamic development and deployment of computing applications including a development framework, a visual design subsystem, and a deployment subsystem, where at runtime the deployment subsystem is operable to dynamically deploy a computing application by sending a request at runtime for graphs and components identified in the computing application. | 08-28-2014 |
20140245262 | Integrated Software Development and Deployment Architecture and High Availability Client-Server Systems Generated Using the Architecture - An integrated software development and deployment architecture includes an application server/operating environment component that implements business intelligence to provide client-server based software solutions, a messaging component that connects the application server/operating environment component with client applications, and a rapid application development component that permits fast, efficient development of application software for deployment in the application server/operating environment using the integrated messaging component. | 08-28-2014 |
20140258975 | ENRICHMENT OF ENTITY RELATIONAL MODEL - The present disclosure describes methods, systems, and computer program products for enriching an entity relational model. One computer-implemented method includes accessing entity relationship settings (ERS), entity relationship data (ERD), and software code with an entity relationship monitor (ERM), monitoring software code by a computer for changes related to software entities associated with the software code, interfacing with a software development tool to monitor for activity in the software development tool related to the software entities, determining that a change or activity related to the software entities has occurred, determining that a relatedness value associated with the software entities associated with the change or activity is within a relatedness threshold specified by the ERS, and performing a function associated with the determined change or activity. | 09-11-2014 |
20140258976 | SYSTEM AND METHOD FOR MANAGING TRACEABILITY SUSPICION WITH SUSPECT PROFILES - A method, computer program product, and computer system for generating, at a computing device, a first suspect profile of a plurality of suspect profiles that includes one or more characteristics, wherein the first suspect profile is associated with a traceability link between at least two artifacts. A change to a first characteristic associated with a first artifact of the at least two artifacts is determined. Which of the plurality of suspect profiles includes the first characteristic is determined. The first characteristic is matched to the first suspect profile of the plurality of suspect profiles based upon, at least in part, determining that the first suspect profile includes the first characteristic. The traceability link is marked as suspect based upon, at least in part, matching the first characteristic to the first suspect profile. | 09-11-2014 |
20140258977 | METHOD AND SYSTEM FOR SELECTING SOFTWARE COMPONENTS BASED ON A DEGREE OF COHERENCE - Disclosed is a novel system and method to select software components. A set of available software components are accessed. Next, one or more dimensions are defined. Each dimension is an attribute to the set of available software components. A set of coherence distances between each pair of the available software components in the set of available software components is calculated for each of the dimensions that have been defined. Each of the coherence distances are combined between each pair of the available software components that has been calculated in the set of the coherence distances into an overall coherence degree for each of the available software components. Using the overall coherence degree, one or more software components are selected to be included in a software bundle. | 09-11-2014 |
20140258978 | SYSTEM AND METHOD FOR TRACKING SUSPICION ACROSS APPLICATION BOUNDARIES - A method, computer program product, and computer system for receiving, from a first and second application by a computing device, shapes of artifacts and components of the first and second application. The shapes of the artifacts and components of the first and second application are conformed to a standard format. One or more changes to the shapes of the artifacts and components of the first and second application are tracked. One or more suspicious relationships across the first and second application are displayed based upon, at least in part, the one or more changes to the shapes of the artifacts and components of the first and second application. | 09-11-2014 |
20140258979 | CLOUD-BASED LOCALIZATION PLATFORM - Systems, methods, and computer-readable media having computer-executable instructions embodied thereon that generate notifications that are delivered to translators who provide updates or translations that are included in localization resources for software applications are provided. Resources are stored on a cloud device in a development file or a public database. The public database stores the content that is selected for modification or translation. The languages may be selected by one or more application developers or may be based on a geographic region associated with the content or the language currently associated with the content. One or more translators are identified based on matches to translator profiles included in the public database. The matching translators receive notifications, which inform the translator that updates or translations are requested. In turn, the translators may access the public database and provide the updates or translations. | 09-11-2014 |
20140258980 | SYSTEM FOR SELECTING SOFTWARE COMPONENTS BASED ON A DEGREE OF COHERENCE - Disclosed is a novel system and method to select software components. A set of available software components are accessed. Next, one or more dimensions are defined. Each dimension is an attribute to the set of available software components. A set of coherence distances between each pair of the available software components in the set of available software components is calculated for each of the dimensions that have been defined. Each of the coherence distances are combined between each pair of the available software components that has been calculated in the set of the coherence distances into an overall coherence degree for each of the available software components. Using the overall coherence degree, one or more software components are selected to be included in a software bundle. | 09-11-2014 |
20140258981 | SYSTEM AND METHOD FOR MANAGING TRACEABILITY SUSPICION WITH SUSPECT PROFILES - A method, computer program product, and computer system for generating, at a computing device, a first suspect profile of a plurality of suspect profiles that includes one or more characteristics, wherein the first suspect profile is associated with a traceability link between at least two artifacts. A change to a first characteristic associated with a first artifact of the at least two artifacts is determined. Which of the plurality of suspect profiles includes the first characteristic is determined. The first characteristic is matched to the first suspect profile of the plurality of suspect profiles based upon, at least in part, determining that the first suspect profile includes the first characteristic. The traceability link is marked as suspect based upon, at least in part, matching the first characteristic to the first suspect profile. | 09-11-2014 |
20140258982 | SYSTEM AND METHOD FOR TRACKING SUSPICION ACROSS APPLICATION BOUNDARIES - A method, computer program product, and computer system for receiving, from a first and second application by a computing device, shapes of artifacts and components of the first and second application. The shapes of the artifacts and components of the first and second application are conformed to a standard format. One or more changes to the shapes of the artifacts and components of the first and second application are tracked. One or more suspicious relationships across the first and second application are displayed based upon, at least in part, the one or more changes to the shapes of the artifacts and components of the first and second application. | 09-11-2014 |
20140282394 | INVOCATION OF EXTERNAL WEB SERVICES USING DYNAMICALLY GENERATED COMPOSITE APPLICATIONS - A system is provided that invokes an external web service using a composite application. The system creates a composite application definition, where the composite application definition includes external web service information and a mapping of a task operation to a service operation. The system further dynamically generates the composite application based on the composite application definition, where the composite application includes computer code. The system further deploys the composite application. | 09-18-2014 |
20140282395 | APPLICATION COMPATIBILITY CHECKING IN A DISTRIBUTED COMPUTING ENVIRONMENT - In various embodiments, methods and systems for maintaining compatibility between applications, based on feature-set constraints are provided. A distributed computing system provides Platform as a service (PaaS) including a software framework in a service model of cloud computing. A known compatibility baseline is established for features of a first application and a second application. The known compatibility baseline inherently includes a baseline set of unenumerated features of the applications. It is determined that the first application is compatible with second application based on comparing an explicit enumeration of added features or removed features in a feature set of the applications. The added features or removed features are tracked after the baseline set of unenumerated features is defined. The determination whether the first application and the second application are compatible is communicated for processing the first application and/or the second application. | 09-18-2014 |
20140282396 | COMPUTERIZED SYSTEM AND METHOD FOR EXTRACTING BUSINESS RULES FROM SOURCE CODE - Systems, methods, and computer program products for extracting business rules from source code are disclosed. The system includes a receiver module on a computer, an analysis module on a computer, and an extraction module on a computer. The receiver module may receive source code and a copybook associated with the source code. The analysis module may analyze the source code to identify a dependency on a portion of the copybook, append the identified portion of the copybook to the identified dependency in the source code to create a consolidated source code file and identify one or more business rules from the consolidated source code file. The extraction module may extract the one or more business rules from the consolidated source code file. | 09-18-2014 |
20140289702 | Methods and Systems for Managing Data Service Specifications - Development of network-based computing resources can be enhanced through the use of methods and systems that allow for controlled editing of specification data used in an automated build process in a user-friendly way. Particularly, one or more software tools can be used to allow editing of application proramming interfaces (API) specification data such as Web Application Description Language (WADL) or Web Service Description Language (WSDL) and/or to allow editing of elements used to generate software development kit (SDK) documentation relied upon by an automatic build system. This editing ability may lead to improved workflows whereby development personnel may have more direct access to portions of the API specification and may readily see the results of their efforts. | 09-25-2014 |
20140310686 | SYSTEM AND METHOD FOR META-DATA DRIVEN, SEMI-AUTOMATED GENERATION OF WEB SERVICES BASED ON EXISTING APPLICATIONS - Techniques for reusing logic implemented in an existing software application such that the logic can be exposed as a Web service or in any other service-oriented context. In one set of embodiments, a design-time technique is provided that comprises, inter alia, receiving program code for an existing software application, generating metadata based on the program code, and customizing the metadata to align with an intended Web service. Artifacts for the Web service are then generated based on the customized metadata. In another set of embodiments, a run-time technique is provided that comprises, inter alia, receiving a payload representing an invocation of a Web service operation of the generated Web service, processing the payload, and, based on the processing, causing the existing software application to execute an operation in response to the invocation of the Web service operation. | 10-16-2014 |
20140317598 | AUTOMATING THE ANALYSIS OF APPLICATION LIFECYCLE MANAGEMENT DATA FOR SOFTWARE DEVELOPMENT - A computer analyzes application lifecycle management data to calculate waste and inefficiency. The computer receives application lifecycle management (ALM) data that includes workflow artifacts, workflow artifact states, and linkage between the workflow artifacts. The ALM data also includes time stamps associated with the workflow artifacts and linkages. The computer calculates lag time between the time stamps of the ALM data. The lag times measure the timeliness of collaboration and communication within a software development project, and based on the calculated lag times or averages, the computer generates visualizations including value steam maps, lag time visualizations or waste reduction visualizations. These visualizations can monitor the performance of a team or can be used to compare the performance of multiple teams throughout a software development project. | 10-23-2014 |
20140325477 | METHOD AND SYSTEM FOR VISUALIZATION OF LARGE CODEBASES - A method for visualizing a codebase includes receiving a dependency graph of the codebase, the dependency graph having nodes and dependencies between the nodes, receiving an abstraction hierarchy of the codebase with abstraction levels, generating, based on the dependency graph and the abstraction hierarchy, a hierarchical graph, positioning each of the nodes on a code map using the hierarchical graph one abstraction level at a time, generating at least one contiguous surface for the code map with a portion of the nodes, and rendering the code map. | 10-30-2014 |
20140325478 | VISUALIZATION OF COMPLEX SYSTEMS USING BUILDINGS - Provided herein are approaches for generating a visualization of software code using a set of buildings. Specifically, one approach comprises: representing software code using a set of buildings in a virtual city environment, wherein each building of the set of buildings represent a software solution; displaying the set of buildings in the virtual city environment; and displaying a plurality of floors and a plurality of rooms within each of the plurality of floors of the set of buildings, wherein each of the plurality of floors of a building of the set of buildings represents a software component of the software solution represented by the building, and wherein each of the plurality of rooms within each floor of the building represents a different version of the software component represented by the floor of the building. | 10-30-2014 |
20140337818 | SYSTEM AND METHOD FOR FORWARDING A COMMAND STREAM - A system and method for forwarding a command stream. A command API may receive a command stream where the command stream contains command information executable as a commands. The command API may process the received command stream to generate a processed command stream where the processed command stream contains equivalent command information to the command information contained in the command stream. A source redirector may encode the processed command stream to generate a formatted command stream. A source protocol stack may send the formatted command stream to a target platform. A target redirector may receive and decode the formatted command stream. The target redirector may process the decoded formatted command stream to generate a target command stream where the target command stream contains equivalent command information contained in the formatted command stream. | 11-13-2014 |
20140351789 | SYSTEM AND METHOD FOR MANAGING IMMUTABLE OBJECTS - A system and method of managing immutable objects includes monitoring new object construction, detecting construction of an object, determining a key for the object, looking the key up in a persistent storage system, when the key is found in the persistent storage system, loading the object from the persistent storage system, and when the key is not found in the persistent storage system constructing the object, determining whether the object is immutable, and storing the object in the persistent storage system when the object is immutable. In some examples, determining whether the object is immutable includes examining each primitive type data member of the object, examining each reference type constructor parameter of the object to determine whether the reference type constructor parameter is defensively copied, examining all function calls used by the object to determine whether the function calls preserve immutability, and recursively examining each reference type data member of the object. | 11-27-2014 |
20140351790 | INTERNET OF THINGS (IOT) APPLICATION DEVELOPMENT - An application development system for development of Internet of Things (IoT) application includes a cataloging module to obtain an input from an application developer. The input comprises data related to the IoT application to be developed. The cataloging module further retrieves a plurality of reusable artefacts from a knowledge database based on the input. A recommendation module in the application development system recommends, to the application developer, artefacts from amongst the plurality of reusable artefacts, based at least on one of a feedback associated with each of the plurality of reusable artefacts, an expert analysis, and a combination of the expert analysis and the feedback. An association module in the application development system associates artefacts selected by the application developer with each other for development of the IoT application. | 11-27-2014 |
20140359575 | ADAPTIVE CONTEXTUAL GRAPHICAL REPRESENTATION OF DEVELOPMENT ENTITIES - In some example implementations, there is provided a method. The method may include receiving, at an interface, a selection of one of a plurality of elements of a tool bar, the plurality of elements including an application structure element and a where-used element; obtaining, in response to the selected element, at least one view providing a graphical representation of context information for a component of a system; and providing to a user interface the at least one view as a stream to allow presentation at the user interface. Related systems, methods, and articles of manufacture are also provided. | 12-04-2014 |
20140365999 | METHODS AND SYSTEMS FOR RECORD EDITING IN APPLICATION DEVELOPMENT - A method of generating a schema including receiving a data record having a record type name and one or more data values is provided. The data values are associated with data value names. The method includes determining whether a set of existing schemas includes a schema associated with the record type name, determining whether the schema includes an element having the same name as a corresponding data element of the record, and validating the corresponding data element against the schema element. A new schema element is added to the schema, the new schema element having the same name and type as the corresponding data element of the record. The method can further include indexing at least one of the one or more data values, which involves querying the indexed data, forming subscription lists for the data values, and forming a derived data value associated with one or more data values. | 12-11-2014 |
20140366000 | Platform for enabling creation and use of an API for a specific solution - The embodiments herein relate to creating solutions for a platform and, more particularly, to enabling a user to create an API (Application Programming Interface) for a platform and enabling at least one other user to use a created API for his platform. Embodiments herein disclose a system which complies with component-based and service-oriented concepts of API architecture, and by providing next generation tools and libraries for open-standards based multi-channel application development by automated generation of APIs and interactive consumption of the APIs via one single portal. | 12-11-2014 |
20140366001 | SYSTEM FOR DISPLAYING NOTIFICATION DEPENDENCIES BETWEEN COMPONENT INSTANCES - The disclosed embodiments relate to a system that facilitates developing applications in a component-based software development environment. This system provides an execution environment comprising instances of application components and a registry that maps names to instances of application components. Within the registry, each entry is associated with a list of notification dependencies that specifies component instances to be notified when the registry entry changes. Upon receiving a command to display notification dependencies for the registry, the system generates and displays a dependency graph containing nodes representing component instances and arrows between the nodes representing notification dependencies between the component instances. Upon receiving a command to display a timeline for with the registry, the system generates and displays a timeline representing events associated with the registry in chronological order. | 12-11-2014 |
20140372978 | SYSTEM AND METHOD FOR ANALYZING AN IMPACT OF A SOFTWARE CODE MIGRATION - A system for analyzing an impact of a software migration on a codebase includes a data management module to receive user-selected input of a codebase that supports international classification of diseases, ninth revision (ICD-9) codes and that contains a plurality of lines of source code and a plurality of codebase components, to receive user selection of at least one search string and to analyze the codebase using the at least one search string to identify at least one of each impacted line of the plurality of lines of source code in the codebase and each impacted codebase component, each impacted line of source code and each impacted codebase component requiring modification in order to support migration from ICD-9 codes to international classification of diseases, tenth revision (ICD-10) codes, and produce at least one report of a result of the analysis of the codebase. | 12-18-2014 |
20140372979 | METHODS AND SYSTEMS FOR DEPLOYING SOFTWARE APPLICATIONS - A method for assembling a plurality of software modules for executing at least one task is described. The method includes selecting at least one software module from a plurality of available software modules, the one or more software modules selected based on at least one task to be performed, if more than one software module is selected, then configuring the selected software modules to function together in a manner to perform the at least one task to be performed, and generating a cyber package including the at least one software module, the cyber package conforming to a pre-defined protocol. | 12-18-2014 |
20140380274 | SOFTWARE LOGISTICS PROTOCOLS - Techniques for using a software logistics protocol include initiating, using the software logistics protocol, a software logistics process, the software logistics protocol being a common application programming interface (API) for controlling and managing the life cycle and operation of a plurality of different software logistics processes; monitoring, using the software logistics protocol, the progress of execution of the software logistics process; and gathering, using the software logistics protocol, output information from the software logistics process after the software logistics process finishes executing. | 12-25-2014 |
20140380275 | MECHANISM FOR COMPATIBILITY AND PRESERVING FRAMEWORK REFACTORING - The subject disclosure relates to enabling the evolution of a framework by providing public surface area factorings for both old and new public surface areas. The factoring can mitigate changes in the implementation of existing distributions of framework. The factoring can also mitigate breaking existing binaries. Further, the factoring can be provided while mitigating a degradation in the security guarantees of the linking model. The factorings can be applied for runtime and/or for a development toolkit. Thus, multiple, almost simultaneous, interoperable views of a framework implementation can be enabled at runtime and/or at design or build time. The views can represent different versions of the framework. | 12-25-2014 |
20150020046 | LOGGING AND PROFILING CONTENT SPACE DATA AND COVERAGE METRIC SELF-REPORTING - A computer-implemented method for generating user stories for a software product, includes collecting, by a processor, a plurality of requirements, creating, by the processor, a plurality of content space specification files that includes the plurality of requirements, processing, by the processor, the plurality of content space specification files to generate the user stories that are related to real time data of the software product, defining, by the processor, a content space, mapping, by the processor, the user stories to the content space and embedding, by the processor, the content space with the software product, wherein user stories include at least one of real time log data, profile statistics data, and coverage metric self-reporting data. | 01-15-2015 |
20150020047 | SOFTWARE PRODUCT LICENSING BASED ON A CONTENT SPACE - A computer-implemented method for generating software license types, includes collecting, by a processor, a plurality of software product functions, creating, by the processor, a plurality of content space specification files that includes the plurality of software product functions, processing, by the processor, the plurality of content space specification files to generate a plurality of software license types and outputting, by the processor, the plurality of software license types. | 01-15-2015 |
20150020048 | COMPONENT DISCOVERY FROM SOURCE CODE - A method for component discovery from source code may include receiving source code, and determining business classes by excluding packages and classes in the source code identified as belonging to a presentation layer, as belonging to a data access layer, as models and/or as utilities. The method may further include extracting multi-dimensional features from the business classes, estimating similarity for business class pairs based on the extracted multi-dimensional features, clustering the business classes based on the similarity and mapping functional concepts to the clusters. The clusters generated by the clustering may represent components of the source code. The method may also include determining interfaces for the components based on the clustering. | 01-15-2015 |
20150046903 | PREDICTING IMMEDIATE BUILD TARGETS - Respective dependencies are identified for each build target in a plurality of build targets. In response to scheduling a build for any build target in the plurality of build targets, determining that all dependencies for a build target in the plurality of build targets have one of the following classifications list: no build is required, built, currently being built, and ready to build, and classifying the target as available for preparatory build activities. In another aspect of the invention, each build target in the plurality of build targets that is available for preparatory build activities is classified as considered to be built. For these build targets, in response to scheduling a build for a build target in the plurality of build targets, classifying the target as available for preparatory build activities. | 02-12-2015 |
20150074639 | UNIFIED SERVICE MANAGEMENT - The described unified service management system provides a unified console to perform functions of individual management specialists. A unified console facilitates an administrator to perform the complex tasks that were performed by the individual management specialists. The unified console provides a “wizard” based approach to the administrator to design all aspects of the complex tasks including placement of components or computing devices, deciding on policies of the components or computing devices, deciding on health policies of components or computing devices, fixing data protection policies of components or computing devices, etc. | 03-12-2015 |
20150082277 | Automatic Pre-detection of Potential Coding Issues and Recommendation for Resolution Actions - A tool for automatic pre-detection of potential software product impact according to a statement placed in a software development system, and for automatically recommending for resolutions which accesses a repository of information containing a history of changes and effects of the changes for a software project; using a received a statement in natural language to perform a natural language search of the repository; according to the findings of the search of the repository, using a machine learning model to compose an impact prediction regarding the received statement relative to the findings; and automatically placing an advisory notice regarding to the impact prediction into the software development system, wherein the advisory notice is associated with the received statement. | 03-19-2015 |
20150089472 | SOFTWARE DISCOVERY BY AN INSTALLER CONTROLLER - A method for performing software discovery by an installer controller is provided and may include detecting, at a computer, an attempt by a software installer to execute on the computer, wherein during execution, the software installer modifies software on the computer. A Software Asset Management (SAM) computer server may be queried for an approval status corresponding to a software package provided by the software installer. The installer controller executes the software installer upon receiving on the returned approval status; aggregates a result from the execution of the software installer based on the software installer modifying the software on the computer; and updates a discovery software signature on the computer when the returned approval status is marked as known. | 03-26-2015 |
20150089473 | SOFTWARE DISCOVERY BY AN INSTALLER CONTROLLER - A method for performing software discovery by an installer controller is provided and may include detecting, at a computer, an attempt by a software installer to execute on the computer, wherein during execution, the software installer modifies software on the computer. A Software Asset Management (SAM) computer server may be queried for an approval status corresponding to a software package provided by the software installer. The installer controller executes the software installer upon receiving on the returned approval status; aggregates a result from the execution of the software installer based on the software installer modifying the software on the computer; and updates a discovery software signature on the computer when the returned approval status is marked as known. | 03-26-2015 |
20150095885 | Integrating Search With Application Analysis - Aspects of the subject matter described herein relate to searching. In aspects, a software package may be received and transformed into searchable data. Static and dynamic analysis may be performed on code and data included in the software package. A data structure is created that may index the code, metadata, indexable resources, and analysis artifacts associated with the software package. The data structure may be used to satisfy queries and the transformed data and analysis artifacts may be made available for viewing. | 04-02-2015 |
20150113504 | VIRTUAL HYBRID APPLICATION - A mobile communication device that includes native and non-native capabilities has a single application platform, that is compatible with the operating system environment of the mobile communication device, and it has a plurality of instances of content that are created remotely from the mobile communication device and transmitted to the communication device over a network. The single application platform interacts with the operating system to control the operation of a native or non-native capability to display at least one of the plurality of instances of the content. A mobile communication device user enters commands into the communication device that when processed by the application platform allow the user to interact with the content. | 04-23-2015 |
20150113505 | MANAGING BUILD VARIANTS IN A COMMON REPOSITORY - A system includes determination of first coordinates in a repository coordinate system associated with a seed component corresponding to a target build result of a first code building system, the seed component comprising a projection method between the repository coordinate system and a variant coordinate system of the first code building system, determination of second coordinates in the variant coordinate system, the second coordinates associated with an execution environment of the target build result, determination of third coordinates in the repository coordinate system based on the first coordinates, the second coordinates and the projection method, and association of the target build result with the third coordinates. | 04-23-2015 |
20150121338 | PROVIDING CONTEXT IN A SWF FILE PROCESSOR - A SWF processing tool, a computer-readable storage medium, and method are provided that give accurate feedback about processing of a SWF file. Discrepancies between the development environment that is used to create a SWF file and features of the SWF processing tool are notified by a warning system that provides context for warning messages. A parser creates a set of interconnected nodes that have edges between a root node, nodes for at least one scene, nodes for control tags and nodes for display object tags, in which the display object nodes are not directly connected by an edge to a scene node. The tags are processed such that when a warning condition is determined for a tag, a representative path of edges connecting the node associated with the tag to the root node is retrieved. A combination of the representative path and a warning message can be displayed. | 04-30-2015 |
20150121339 | CODE STACK MANAGEMENT - Embodiments relate to code stack management. An aspect includes a processor configured to execute a software application. Another aspect includes a code stack memory area and a data stack memory area, the code stack memory area being separate from the data stack memory area. Another aspect includes maintaining a data stack in the data stack memory area, the data stack comprising a plurality of stack frames comprising one or more data variables corresponding to the execution of the software application. Another aspect includes maintaining a code stack in the code stack memory area, the code stack comprising a plurality of code stack entries comprising executable computer code corresponding to the execution of the software application. | 04-30-2015 |
20150128109 | STRUCTURE ANALYSIS DEVICE AND PROGRAM - A structure analysis device comprises a storage means wherein modules are stored, and an analysis means for carrying out a structural analysis of a prescribed subject module of the modules which are stored in the storage means. If a hierarchical structure of a first subject range and a hierarchical structure of a second subject range of the subject module are the same, the analysis means creates similarity notification information in association with the first subject range and/or the second subject range. The first subject range and the second subject range are respectively different subject ranges of the subject ranges of the subject modules which are acquired from the storage means. The similarity notification information denotes that respectively similar subject ranges are present in the subject module. | 05-07-2015 |
20150135163 | SERVER PROVIDING CLOUD SERVICE, TERMINAL FOR DEVELOPER AND METHOD FOR SUPPORTING APPLICATION DEVELOPMENT USING THE SAME - Disclosed are a server providing a cloud service, a terminal for a developer and a method for supporting application development using the same, the method of supporting application development using a cloud service. The method including: accessing an integrated system providing a cloud service; selecting a developing environment corresponding to a development-target application through a template provided by the integrated system; creating an application based on the developing environment; and verifying the created application using an object image provided by the integrated system and rendered with regard to at least one device where an application is to be driven. Thus, the developer can easily construct the application developing environment without purchase and complicated installation procedures for constructing the integrated environment. | 05-14-2015 |
20150143332 | FUNCTIONAL ARCHITECTURE PATTERN FOR SAFETY APPLICATIONS - A process for decomposing safety software involves the steps of providing a first software module associated with a first logical unit, providing a second software module associated with a second logical unit, instructing the first software module to implement a first safety goal based on a quality management level, and instructing the second software module to implement a second safety goal based on a safety integrity level, where the second software module uses at least one input and at least one output of the second logical unit to determine if the second safety goal is satisfied. Consequently, the second software module uses a result of the first software module to determine if the first safety goal has been completed, and the second software module uses at least one algorithm to verify an operational status of the first logical unit. | 05-21-2015 |
20150143333 | Native Application Variation - From one aspect, a computer implemented method, apparatus and computer program product is provided for varying at least one element of a plurality of elements of a viewable area of a native software application during runtime on a first computing device, the method comprising highlighting at least one element of the viewable area of a native software application, receiving a user input relating to a selection of the element and information relating to a modification of the element; storing, as element information, an identifier of the selected element and the modification information of the selected element, and transmitting the element information to a server computer system if a network connection is available. | 05-21-2015 |
20150143334 | MESSAGE EXCHANGE PATTERN RENDEZVOUS ABSTRACTION - A rendezvous abstraction that is used to correlate messages within message exchange. The rendezvous abstraction may be instantiated to correlate messages regardless of the type of message exchange pattern, and regardless of the underlying protocols used to communication message. Messages exchanges of primitive protocols are modeled as unilateral message exchanges. The rendezvous abstraction is used to correlate messages of the unilateral message exchange, and serves as an abstraction that is used to represented the rendezvous point where the message of the message exchange pattern are handled. Accordingly, instead of focusing on the protocol-specific mechanisms for correlation, if even available, the application author may simply work with a standard rendezvous abstraction. | 05-21-2015 |
20150293761 | CLASSIFICATION AND DISPLAY OF CODE EXECUTION PROFILE DATA - Methods for classifying functions as belonging to a particular software system is disclosed. Various embodiments are also described that use and display the result of the function classification in various ways, regardless of whether the information was generated by any particular of the described methods. One example graph combines function membership data, time interval frame data, and call stack profile data in the form of an Icicle Graph. The Icicle Graph is then distorted into a Sunburst Graph, resulting in an overall Software System Sunburst Icicle Graph. | 10-15-2015 |
20150293762 | Smart Source Code Evaluation and Suggestion System - A method for s identifying program files within one or more programs that will likely require update to implement a proposed programming task is disclosed. A processor identifies a previous programming task that matches the proposed programming task. The processor also identifies a set of program files that were updated to implement the previous programming task. The processor then displays the set of program files or existing versions of the set of program files as program files that will likely require update for the proposed programming task. | 10-15-2015 |
20150309788 | FUNCTION MODULE MODULARIZING METHOD IN DATA DISTRIBUTION SERVICE AND MODULARIZING APPARATUS THEREOF - Disclosed is a modularizing apparatus modularizing a function module in DDS middleware, including: a DCPS module providing an interface with an application program; and a library module initializing and creating the function module, classifying the created function module for each function and storing the classified function module, and providing a function module corresponding to a request by the DCPS module to the DCPS module. | 10-29-2015 |
20150324191 | UNIVERSAL AND ADAPTIVE SOFTWARE DEVELOPMENT PLATFORM FOR DATA-DRIVEN APPLICATIONS - A software application platform that abstracts a computing platform, a database layer, and a rendering medium is disclosed. A platform-independent application programming interface is disclosed, as well as an abstract database layer. The abstraction of the database layer comprises two sub-layers, including a layer having a uniform interface that treats data records as plain objects and a layer having constructs that facilitate the automated generation of user interfaces for data record navigation and management. Further, a software application platform that is independent of rendering medium is disclosed. | 11-12-2015 |
20150324192 | SYSTEM AND METHOD FOR CREATING, MANAGING, AND REUSING SCHEMA TYPE DEFINITIONS IN SERVICES ORIENTED ARCHITECTURE SERVICES, GROUPED IN THE FORM OF LIBRARIES - A computer-implemented system and method for creating, managing, and reusing schema type definitions in SOA services, grouped in the form of libraries are disclosed. The method in an example embodiment includes: grouping a plurality of Extensible Mark-up Language (XML) schema (XSD) types, each XSD type defined in an individual XSD file; using a processor to bundle the plurality of individual XSD types into a type library, the type library including a type information file to register the individual XSD types in the type library, the type library further including a type dependencies file to register dependencies between the individual XSD types in the same or different type library; importing types from a different type library, when defining derived types or aggregated types; generating Java artifacts from the XSD types; and associating the Java artifacts with corresponding XSD types in the type information file of the type library. | 11-12-2015 |
20150347119 | AUTOMATIC DEPLOYMENT AND UPDATE OF HYBRID APPLICATIONS - Described herein is a framework for deploying and updating applications (Apps). In accordance with one aspect, a source code of a hybrid application may be provided by a development environment running on a cloud server, in response to a user event. A deployment generator running on the cloud server may be automatically invoked to receive the source code of the hybrid application. The source code of the hybrid application may be further packaged to form a hybrid application package for deployment by the deployment generator. The hybrid application package may be deployed to a deployment service on the cloud server. | 12-03-2015 |
20150355901 | METHOD AND SYSTEM TO AUTOMATE THE MAINTENANCE OF DATA-DRIVEN ANALYTIC MODELS - A method, system, and non-transitory computer-readable medium, the method including determining automatically, by a processor, whether behavior for a model representing a plurality of entities and relationships therebetween deviates from a reference behavior for the model; determining, in response to the determination that the model does deviate from the reference behavior, at least one basis for the deviation; automatically forecasting an estimate of a remaining useful life for the model; and modifying the model to compensate for the deviation by at least one of modifying the model to accommodate the deviation and updating the model based on at least one new requirement. | 12-10-2015 |
20150355902 | TRANSPARENT TYPE-BASED OBJECT AUGMENTATION BY ORTHOGONAL FUNCTIONALITY - Tools and techniques are described for transparently and safely augmenting the functionality of objects in an existing collection of objects. One approach automatically creates a dynamic interface for a known object type T, having the same type signature as T. Augmentations which implement the interface are then recognized, and an interpreted or compiled code environment is adjusted to invoke their functionality, which is orthogonal to the indicated functionality of type T. An application program executing in the adjusted environment automatically and transparently generates an instance of each augmentation, and the augmentations are composed to run when the original object of type T is accessed. Some suitable orthogonal functionalities include: data logging, event logging, data validation, event validation, localization of strings, localization of a display format, administrator alerts, inspection of data without alteration of the data, malware scanning, scanning for a code security vulnerability, or reporting on one of the foregoing. | 12-10-2015 |
20150363193 | AUTOMATIC SOFTWARE CATALOG CONTENT CREATION BASED ON BIO-INSPIRED COMPUTING PREDICTION - A computer system for automatically creating a software catalog content that includes a plurality of software components associated with a computing system is provided. The computer system may include creating a population comprising a plurality of potential software signatures associated with the plurality of software components. The computer system may include ranking the population based on a highest ratio value. The computer system may include selecting a set of parent software signatures based on the ranking. The computer system may include creating a new population of potential software signatures based on the selected set of parent software signatures. The computer system may include performing recombination on the new population of potential software signatures. The computer system may include predicting at least one potential software signature from the new population of potential software signatures based on a comparison between the performed recombination and the created new population of potential software signatures. | 12-17-2015 |
20150363194 | AUTOMATIC SOFTWARE CATALOG CONTENT CREATION BASED ON BIO-INSPIRED COMPUTING PREDICTION - A method for automatically creating a software catalog content that includes a plurality of software components associated with a computing system is provided. The method may include creating a population comprising a plurality of potential software signatures associated with the plurality of software components. The method may include ranking the population comprising the potential software signatures based on a highest ratio value. The method may include selecting a set of parent software signatures based on the ranking. Additionally, the method may include creating a new population of potential software signatures based on the selected set of parent software signatures. The method may include performing recombination on the new population of potential software signatures. Furthermore, the method may include predicting at least one potential software signature from the new population of potential software signatures based on a comparison between the performed recombination and the created new population of potential software signatures. | 12-17-2015 |
20150378700 | POLICY MANAGEMENT OF DEPLOYMENT PLANS - A deployment system enables a developer to define a logical, multi-tier application blueprint that can be used to create and manage (e.g., redeploy, upgrade, backup, patch) multiple applications in a cloud infrastructure. The deployment system supports the use of nested policies to manage a deployment plan. Upon determining compliance to the nested policies, the application can be deployed according to an application blueprint, which means any needed VMs are provisioned from the cloud infrastructure, and application components and software services are installed. | 12-31-2015 |
20150378720 | NUCLEUS ARCHITECTURE - A medical software package stored on a non-transitory, computer-readable storage medium is disclosed. The medical software package can include a plurality of software components programmed to provide one or more functionalities to one or more medical monitoring devices, where each software component is programmed to run independently as a daemon, where each software component is programmed to be modified without recompiling unchanged software components, where the software components are programmed to communicate to each other through at least one of the software components, and where the software package is hardware agnostic and operating system agnostic. A medical device including a tangible, non-transitory storage device storing a medical software package comprising a plurality of modular software components programmed to provide medical device functionality is also disclosed. | 12-31-2015 |
20150378725 | MULTI-STAGE PUSH NOTIFICATIONS FOR SOFTWARE LOGISTIC TOOLS - An incident associated with a software logistic tool occurs. At a host agent a notification for the incident is received. The host agent is associated with a corresponding host where the software logistic tool is running. The notification for the incident is pushed to a customer operation cockpit operating at a customer system landscape via a push channel for communication from the software logistic tool to the customer operation cockpit. The notification for the incident is received at the customer operation cockpit for a customer support user to analyze. | 12-31-2015 |
20160004520 | OPTIMIZATION OF COMPUTER MODULES FOR THE DEPLOYMENT OF A COMPUTER SERVICE - The invention relates to an automated selection of optimal computer modules for deploying a computer service. For this purpose, the following steps are provided:
| 01-07-2016 |
20160004532 | SELF-DESCRIBING DEVICE MODULE AND SYSTEM AND COMPUTER-READABLE MEDIUM FOR THE PRODUCTION THEREOF - A system, method, and computer-readable medium for generation of a controlled device Module are provided. Various components are provided to a Module designer for selection, and the designer defines the interface APIs specifying the component functionalities. The designer may specify custom commands or events for the Module including Commands, Properties, and Parameters, and custom components corresponding to the custom commands are generated. A self-describing capabilities component is then generated for each component, and a composite capabilities component may then be generated from the capabilities components of each of the components. The completed Module package is then produced by an integrated development environment station. | 01-07-2016 |
20160011867 | ON-DEMAND DATABASE SERVICE SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT FOR VALIDATING A DEVELOPED APPLICATION | 01-14-2016 |
20160019057 | MANAGING PARAMETER SETS - Managing sets of parameter values includes: receiving a plurality of sets of parameter values for a generic computer program, and processing log entries associated with executions of instances of the generic computer program, each instance associated with one or more parameter values. The processing includes: analyzing the generic computer program to classify each of one or more parameters associated with the generic computer program as a member of either a first class or a second class; processing a log entry associated with an execution of a first instance of the generic computer program to form a particular set of parameter values; and determining whether to add the particular set of parameter values to the plurality of sets of parameter values based on a comparison of a first identifier for the particular set of parameter values to identifiers for at least some of the sets of parameter values. | 01-21-2016 |
20160019059 | 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. | 01-21-2016 |
20160034272 | MANAGING A CATALOG OF SCRIPTS - According to an example, a catalog of scripts may be managed. Management of the catalog of scripts may include the addition of a script description into the catalog of scripts. In one example, the script description may be directly added to the catalog of scripts. In another example, the script description may be added through generation of a merged query of scripts. | 02-04-2016 |
20160054994 | SOURCE PROGRAM ANALYSIS SYSTEM, SOURCE PROGRAM ANALYSIS METHOD, AND RECORDING MEDIUM ON WHICH PROGRAM IS RECORDED - A matching portion detector ( | 02-25-2016 |
20160055081 | NON-PRECISE GARBAGE COLLECTION IN NON-COOPERATIVE SYSTEMS - Embodiments are directed towards garbage collection for an application running on a non-cooperative target platform. Where the garbage collection optimistically manages thread state for transitions to and from native and managed code and that some threads are suspended while others are left executing during garbage collection. When a characteristic of the native code call indicates that a duration of the native code call may exceed a defined duration, state information for the thread may be updated to transition the thread to the unmanaged code environment. When a garbage collection event occurs, thread state information is updated to communicate suspend requests to the threads. Then the runtime may wait for each thread in the managed code environment to be reach a safe state before garbage collection may commence. | 02-25-2016 |
20160062754 | Coordinating Application Deployment with a Platform Tier - Coordinating application deployment with a platform tier includes assigning a platform tier that has at least some capabilities that match application requests specific to an application embodied in an application layer, deploying the application to the platform tier, and performing a development task on the application in the platform tier with the capabilities. | 03-03-2016 |
20160062763 | Resource Processing Using an Intermediary for Context-Based Customization of Interaction Deliverables - A software application includes work order resources, each of which defines an atomic operation for the software application, and a construction service resource, which processes the work order resources in response to all interaction requests for the software application. Each interaction request is received from a client and identifies a corresponding work order, which the construction service processes to dynamically construct a set of deliverables, which can include a custom representation of the work order. While processing the interaction request, the construction service, as directed by the work order, can make one or more requests to context resources for context information corresponding to an activity for which the interaction was requested to construct the set of deliverables. The work order resource can comprise a reflective program that enables the construction service to dynamically determine and construct the set of deliverables, including the next appropriate interaction(s) using the context information, thereby directing a set of atomic operations as part of an activity being performed and enabling the dynamic context-based construction of interaction deliverables. | 03-03-2016 |
20160070564 | DYNAMICALLY SCHEMATIZED LOG MESSAGES FOR SOFTWARE APPLICATIONS - Disclosed herein are systems, methods, and software to enhance log message handling. In an implementation, a message logging service receives log messages that fail to conform to a log schema. The service maps at least a subset of the log messages to a schematized log message that conforms to the log schema. The schematized log message can then be logged in a message log. | 03-10-2016 |
20160070765 | INTEGRATING SEARCH WITH APPLICATION ANALYSIS - Aspects of the subject matter described herein relate to searching. In aspects, a software package may be received and transformed into searchable data. Static and dynamic analysis may be performed on code and data included in the software package. A data structure is created that may index the code, metadata, indexable resources, and analysis artifacts associated with the software package. The data structure may be used to satisfy queries and the transformed data and analysis artifacts may be made available for viewing. | 03-10-2016 |
20160085544 | DATA MANAGEMENT SYSTEM - Systems and techniques are disclosed for improving the management of data contracts during a software development lifecycle. A system can include a data contract metadata store, components for interacting with the metadata store to support development tool integration, and interchange features for verified build processes. A service can be provided that receives a developer package from a development client application, parses the developer package to generate data contract metadata, modifies a data contract metadata store in accordance with at least one command received with the developer package, and communicates notification data, when included with the data contract metadata, to a notification service. | 03-24-2016 |
20160092206 | MANAGING EXECUTABLE FILES - Executable files are managed. A determination is made as to whether in a second executable file there exists a function that is the same as a function called in a first executable file. A data package is generated on a portion other than the function in the first executable file and the second executable file, and the function is stored in relation to the data package. The data package includes a first address of the function in the first executable file and a second address of the function in the second executable file. | 03-31-2016 |
20160103677 | SYSTEM AND METHOD FOR OPTIMIZING JOB SCHEDULING WITHIN PROGRAM BUILDS - A method for executing program builds comprising: analyzing file dependency information and job duration information associated with jobs of the program build; scheduling jobs for a current program build based on the analysis of the dependency information and the job duration data; executing the jobs according to the schedule; collecting file usage information and new job duration information from each of the jobs; supplementing the file dependency information with the file usage information; and storing the new job duration information to be used for scheduling jobs in subsequent program builds. | 04-14-2016 |
20160103678 | MAINTAINING THE INTEGRITY OF PROCESS CONVENTIONS WITHIN AN ALM FRAMEWORK - At least one ALM artifact, indexed by a unified data store, that does not comply with at least one process convention can be identified. Responsive to identifying the ALM artifact, indexed by the unified data store, that does not comply with the process convention, a determination can be made by a process convention agent executed by a processor as to whether script code is available to update the ALM artifact to comply with the process convention. Responsive to the process convention agent determining that script code is available to update the ALM artifact to comply with the process convention, the process convention agent can automatically execute the script code to update the ALM artifact to comply with the process convention. | 04-14-2016 |
20160139902 | AUGMENTED DEPLOYMENT SPECIFICATION FOR SOFTWARE COMPLIANCE - A method of augmenting a deployment specification for a software application to determine a level of compliance of the application with a compliance characteristic, the deployment specification being suitable for identifying a resource required to execute the software application in a virtualised computing environment, the method comprising: receiving a definition of the compliance characteristic as a set of compliance criteria concerning the resource, wherein satisfaction of the compliance criteria during execution of the software application is suitable for determining the level of compliance of the software application with the compliance characteristic; selecting at least one software component from a library of components based on the definition of the compliance characteristic, the software component being operable to determine a state of satisfaction of at least a subset of the set of criteria for the compliance characteristic; and modifying the deployment specification to identify the at least one selected software component such that, on execution of the application, the level of compliance of the application with the compliance characteristic is determined. | 05-19-2016 |
20160147518 | MODEL BASED ENFORCEMENT OF SOFTWARE COMPLIANCE - A method for enforcing a model deployment specification for a software application in execution in a virtualised computing environment, the method comprising: retrieving a compliance characteristic for the application, the compliance characteristic having associated a compliance criterion; receiving a model deployment specification for the compliance characteristic, the model deployment specification including an identification of a set of model resources being selected to, when instantiated, satisfy the compliance criterion; identifying a set of instantiated resources as resources instantiated for execution of the application; in response to a determination that the set of model resources includes absent resources as resources outside the set of instantiated resources, modifying the set of instantiated resources by instantiating the absent resources for execution of the application such that the absent resources are included in the set of instantiated resources. | 05-26-2016 |
20160147529 | Source Code Management for a Multi-Tenant Platform-as-a-Service (PaaS) System - Aspects of the disclosure provide for source code management for a multi-tenant Platform-as-Service (PaaS) system. A method of the disclosure includes creating, by a processing device of a platform-as-a-service (PaaS) system, a first container to host a first source code management repository for an application; receiving, at the first container, source code associated with the application; creating, by the processing device, a second container to provide deployment functionality for the application, the second container comprising resource-constrained processing space of a node of the PaaS system to execute functionality of the application; and deploying, by the processing device, the source code on the PaaS system using the second container. Aspects of the disclosure may be implemented using high-availability (HA) clusters by replicating the SCM container(s). Aspects of the disclosure may provide users with cost-effective, scaled, and secure PaaS services using reduced infrastructure. | 05-26-2016 |
20160170715 | SYSTEMS AND METHODS TO SYNCHRONIZE ARTIFACT RELATIONSHIPS ACROSS A PLURALITY OF REPOSITORIES | 06-16-2016 |
20160170742 | AUTOMATED APPROACH FOR INTEGRATING AUTOMATED FUNCTION LIBRARY FUNCTIONS AND ALGORITHMS IN PREDICTIVE ANALYTICS | 06-16-2016 |
20160170743 | TEMPLATE BASED SOFTWARE CONTAINER | 06-16-2016 |
20160170748 | GENERIC ANNOTATION SEEKER | 06-16-2016 |
20160179501 | CALCULATING CONFIDENCE VALUES FOR SOURCE CODE BASED ON AVAILABILITY OF EXPERTS | 06-23-2016 |
20160179504 | REFACTORING DATA FLOW APPLICATIONS WITHOUT SOURCE CODE CHANGES OR RECOMPILATION | 06-23-2016 |
20160202967 | COMPONENT DISCOVERY FROM SOURCE CODE | 07-14-2016 |
20160202968 | MODULARIZED XML NAMESPACES | 07-14-2016 |
20160378449 | ARTIFACT MANAGER FOR RELEASE AUTOMATION - An artifact manager generates an abstraction for artifacts and repositories in a deployment platform such that the artifacts may be located uniformly and securely in each deployment environment during the deployment process. The described system includes a release automation platform having a release pipeline which is responsible for deploying build artifacts into multiple deployment environments, testing the build artifacts thoroughly in each environment, and follow organization-specific approval processes to promote the build artifacts to a next deployment environment. | 12-29-2016 |
20180024831 | SYSTEM AND METHOD FOR PROVIDING SUPPLEMENTAL FUNCTIONALITIES TO A COMPUTER PROGRAM | 01-25-2018 |
20190146786 | DETERMINING THE AVAILABILITY OF MEMORY OPTIMIZATIONS BY ANALYZING A RUNNING BINARY | 05-16-2019 |