Entries |
Document | Title | Date |
20080235666 | GENERATING SEQUENCE DIAGRAMS USING CALL TREES - A software tool is provided to analyze static source code. Source Code files are selected to define the project work space. A class and a method in the class are selected from said selected source code files. The tool generates a Call Tree as an ordered recursive sequence of all method calls in different classes or their instances that are invoked by said selected method in said selected class. A Sequence Diagram is generated from said Call Tree. The tool remembers all updates to the Call Tree used to generate the Sequence Diagram. This information is used when a generated Sequence Diagram is impacted due to changes made to any source code file included in the project. | 09-25-2008 |
20080250394 | Synchronizing external documentation with code development - Documentation is automatically updated in response to the source code being modified without requiring human intervention. Elements within the source code are marked such that when changes are made to the marked elements within the source code, the documentation is updated to reflect the changes. Therefore, the code may continue to be modified while simultaneously allowing the documentation to be developed. The documentation is stored externally from the source code such that rich formatting may be applied to the documentation and that the documentation process does not inadvertently corrupt the source code. | 10-09-2008 |
20080250395 | Method for Producing Documentation - A method for automatically producing documentation for a project, in which at least one architecture description which describes an architecture of the project having individual architecture elements, and detailed descriptions of the architectural elements are integrated using a configuration management tool. | 10-09-2008 |
20080288922 | SYSTEM FOR GENERATING A TUTORIAL APPLICATION - The invention relates to the field of source code development and in particular a method and system for generating a tutorial application from one or more selected source code elements. The invention provides for a user to select one or source code elements and one or more data elements to be tagged to one or more source code elements. The selected source code elements are tagged using a mark-up language and a tutorial application is generated displaying the tagged selected source code elements and the data elements. | 11-20-2008 |
20090089754 | Detecting Plagiarism In Computer Source Code - Plagiarism of software source code is a serious problem in two distinct areas of endeavor—cheating by students at schools and intellectual property theft at corporations. A number of algorithms have been implemented to check source code files for plagiarism, each with their strengths and weaknesses. This invention detects plagiarism by comparing statements within source code of a first program to comments within source code of a second program. | 04-02-2009 |
20090094580 | DISPLAYING COMMENT STATISTICS INFORMATION - A system, method and program product for statistically analyzing comments in one or more program code listings. A system is disclosed that includes a process for associating comments to blocks of code at different programmatic levels in a code listing; a process for assigning weights to different code blocks, and a process for generating a statistical analysis at the different programmatic levels of the comments in the code listing. | 04-09-2009 |
20090106736 | Heuristics for determining source code ownership - Various technologies and techniques are disclosed for using heuristics to determine source code ownership. A request is received to identify at least one owner of a particular source code unit. Initial ownership totals are calculated for the source code unit based upon a code contribution heuristic. The code contribution heuristic counts lines of code that were added and that were modified in the totals for contributing users. The initial ownership totals of the particular source code unit are adjusted based upon at least one other heuristic. The at least one owner of the particular source code unit is then output to an output device. The at least one owner is determined by selecting a contributing user that has a highest ranking total after adjusting the initial ownership totals. For example, there can be a primary owner and a backup owner selected based on the ranking of the ownership totals. | 04-23-2009 |
20090119644 | DERIVING COMPONENT STATISTICS FOR A STREAM ENABLED APPLICATION - A technique for generating component usage statistics involves associating components with blocks of a stream-enabled application. When the streaming application is executed, block requests may be logged by Block ID in a log. The frequency of component use may be estimated by analyzing the block request log with the block associations. | 05-07-2009 |
20090138852 | Managing Sets of Entities - Methods and apparatus, including computer systems and program products, that implement a description language and a parser for a description language. A method includes receiving input including a specification of base items, a specification of contexts, and a specification of a selected context from the contexts. The method further includes generating an output set of items by evaluating the selected context. In that method, each item in the output set of items includes core attributes of a corresponding base item and can include attributes from a context. Generating an output set of items can include generating a specific bill of materials. | 05-28-2009 |
20090158254 | AUTOMATIC CREATIVE PROPOSAL GENERATING AND FILTERING SYSTEM AND MANUFACTURING METHOD THEREOF AND MULTIPLE COMPONENTS COMBINING METHOD - The present invention discloses an automatic method and system for generating and filtering out the innovation proposals. Particularly, it is about a system, which generates all the possible element code sets, compares them to the code sets of existing objects or documents, and then filters out the novel element code sets. The system comprises a standard element depository, a permutation and combination module, a testing object processing module, a matching module, a sifting module, and an output module. | 06-18-2009 |
20090164974 | QUALITY MEASURE TOOL FOR A COMPOSITE APPLICATION - A method for estimating a quality measure of a composite application is presented. The method may include receiving a set of sequence diagrams describing interactions between pairs of components in a composite application. Each sequence diagram may describe a functional use case of the composite application. Component quality metrics may also be received, such that each component quality metric corresponds to a component of the composite application. A quality estimation may be calculated for each use case of the composite application. The quality estimation may be determined as a function of one or more of the component quality metrics. A quality measure of the composite application may then be calculated as a function of the quality estimation for each use case. The quality measure of the composite application may be output. | 06-25-2009 |
20090210860 | Tagging and logical grouping of items in source code change lists - A tool facilitating organizing code review via tagging changes in the code such that developer reasoning and reviewer comments are captured during the development process; thus documenting the development process. The tool providing intuitive presentation of changes and change sets based on the purpose of the change. The tool enabling retrieval of the information documenting developer and reviewer rationale during development and after development is complete. | 08-20-2009 |
20090210861 | DITA DOCLET TOOL AND METHOD FOR EXTRACTING AND ANALYZING API DOCUMENTATION - A software tool and method for extracting embedded source code documentation into an XML-based file, and then further processing the XML-based file to identify documentation errors corresponding to missing tagging and descriptions for classes, interfaces, methods, parameters, etc. Once the errors are identified, missing tags are filled in, and additional comment tags are created within the XML-based file, identifying the error and presenting possible recommendations for fixing it. The error information may further be highlighted to enhance its visual appearance. | 08-20-2009 |
20100037209 | SOURCE PROGRAM REVIEW PROGRAM, SOURCE PROGRAM REVIEW METHOD, AND SOURCE PROGRAM REVIEW DEVICE - A method for reviewing a modified source program includes extracting review-requiring points to be reviewed, by comparing a pre-modification source program as a source program before a modification and a post-modification source program as a source program after the modification, storing a review history indicating whether each of the review-requiring points extracted at the extracting has been reviewed or is unreviewed, outputting information of the review-requiring points extracted in the extracting, associated with the review history stored in the storing and indicating whether each of the review-requiring points has been reviewed or is unreviewed, to a predetermined output unit, and updating the review history stored in the storing when receiving from a predetermined input unit that the review-requiring point outputted as unreviewed by the predetermined output unit has been reviewed. | 02-11-2010 |
20100107141 | SYSTEM AND METHOD FOR RECOMMENDING NEXT COMMANDS WHEN USING A SOFTWARE APPLICATION - One embodiment of the invention sets forth a mechanism for recommended commands to a designer of a graphics design application. Each time a command is executed within the graphics design application, a resource module receives command use information associated with the executed command. In response, the resource module generates and transmits one or more recommendation lists to the designer, where each recommendation list includes a list of recommended commands that may be executed by the designer next. The resource module generates the recommendation lists based on frequency information associated with the recommended commands stored within a local frequency store. The frequency information is received by the resource module from a central server that processes command use information associated with different designers in the community to produce the frequency information. | 04-29-2010 |
20100122238 | GENERATING FUNCTIONAL ARTIFACTS FROM LOW LEVEL DESIGN DIAGRAMS - At least one design diagram is obtained from at least one previous software project. At least one service abstraction is extracted from the at least one design diagram. The at least one service abstraction is reused in a new software project. In another aspect, requirements are obtained for a current software project; at least one class diagram is obtained from at least one previous software project; a dependency graph is generated from the at least one design diagram, using link analysis; relationships between classes in the dependency graph are analyzed to obtain functional artifacts for the requirements; and the functional artifacts are reused in the new software project. | 05-13-2010 |
20100169866 | NAVIGATION IN COMPUTER SOFTWARE APPLICATIONS DEVELOPED IN A PROCEDURAL LANGUAGE - A system and computer program product for providing a maintenance environment for computer program code Portions of the computer program code are selectively stored and one or more lists of the stored portions are created. Links are created between the lists and the stored portions of the computer program code for navigational purposes. A maintenance environment for the computer program code is provided. | 07-01-2010 |
20100242022 | SYSTEM AND METHOD FOR MANAGING CROSS PROJECT DEPENDENCIES AT DEVELOPMENT TIME - A method for responding to a change in source code, said method comprising: interconnecting a plurality of nodes to form a graph data structure wherein the graph embodies at least one dependency between a plurality of software projects; traversing the graph to identify dependent code affected by the change; evaluating the identified dependent code; and wherein the changed source code is from a first software project and the identified dependent code is from a second software project. | 09-23-2010 |
20100325614 | DETECTING PLAGIARISM IN COMPUTER SOURCE CODE - Plagiarism is detected by comparing statements within source code of a first program to comments within source code of a second program. | 12-23-2010 |
20110029952 | METHOD AND SYSTEM FOR CONSTRUCTING A DOCUMENT REDUNDANCY GRAPH - A system and method for constructing a document redundancy graph with respect to a document set. The redundancy graph can be constructed with a node for each paragraph associated with the document set such that each node in the redundancy graph represents a unique cluster of information. The nodes can be linked in an order with respect to the information provided in the document set and bundles of redundant information from the document set can be mapped to individual nodes. A data structure (e.g., a hash table) of a paragraph identifier associated with a probability value can be constructed for eliminating inconsistencies with respect to node redundancy. Additionally, a sequence of unique nodes can also be integrated into the graph construction process. The nodes can be connected to the paragraphs associated with the document set via a hyperlink and/or via a label with respect to each node. | 02-03-2011 |
20110107303 | METHOD AND SYSTEM FOR HANDLING SOFTWARE DESIGN CONFLICTS - A method and a system for identifying and resolving conflicts between design results from a parallel software design. The method includes: receiving a design diagram, wherein the design diagram includes a plurality of nodes and arrows connecting different nodes, with each node indicating a design artifact, and an arrow directed from one node to another node indicating that a design artifact corresponds to the one node depends on a design artifact corresponding to the other node; determining a level of a design artifact in the design diagram, identifying different design artifacts at a given level of the design diagram that depend on a common design artifact, and marking them as isomorphic design artifacts; and outputting a design diagram with the isomorphic design artifacts marked. A conflict between relevant designs are automatically identified in a bottom-up approach according to a software design hierarchy to facilitate conflict resolution. | 05-05-2011 |
20110138356 | METHOD AND SOFTWARE PROGRAM PRODUCT FOR ON-THE-FLY MATCHING OF MESSAGES - A method of matching message elements, including a reading step of reading a contents of a first message and a second message and a determining step that determines whether the content of the first message is the same as the content of the second message, wherein if the content of the first message matches the content of the second message, a new pair is formed that includes the content of the first message and the content of the second message. The method further includes a matching table lookup step of reading a matching table, which stores one or more pairs of matching elements, a consistency check step to determine whether the new pair is consistent with the one or more pairs of matching elements stored in the matching table, and a storage step for storing the new pair to the matching table based on the result of the consistency check step. | 06-09-2011 |
20110167409 | SYSTEMS AND METHODS FOR SOFTWARE SPECIFICATION AND DESIGN USING A UNIFIED DOCUMENT - A system for improving software specifications and design using a unified document, in one example embodiment, comprises a subsystem to automatically receive a formatted unified document, which can include a plurality of fragments having content formatted and labeled according to predetermined formatting and labeling criteria. The system can further include a subsystem to automatically transform the unified document into a plurality of documents including source code files. The source code files can be immediately executable or executable after being compiled into an executable code. The documents can further include test documents, installation documents, configuration documents, user documents, and edited versions of the unified document. The edited versions of the unified document can be visible by users with appropriate permissions. The formatting of the unified document can comprise assuring that each of multiple parts is formatted according to the appropriate category and selectively labeling each part. The labels can designate descriptions, outlines of data, examples, and assertion statements. The predetermined transformation rules can include transforming the descriptions into data models, transforming the examples into test cases, and transforming the assertion statements into formal assertions of an expression language. | 07-07-2011 |
20110197178 | ARCHITECTURE, SYSTEM, AND METHOD FOR PROVIDING HOVER HELP SUPPORT FOR C++ APPLICATION SOURCE CODE - A method and apparatus for proving hover help support is described. In one embodiment, the method includes loading a documentation file generated from application source code. The method may also include parsing the documentation file to determine a context of elements within the documentation file. Furthermore, the method may include generating a model of the documentation file based on the context of the elements and storing the model in a memory. | 08-11-2011 |
20110231819 | Content Availability Determination, Representation And Acquisition System - A computer implemented method and system is provided for determining availability of one or more content objects and acquiring them for a user. A content management server is provided in communication with a transaction management server via a network. A software component in communication with the content management server is provided on the user's computing device. The software component monitors characteristic information of the user. The software component and/or the content management server determine availability of the content objects for the user based on the characteristic information and context of the software component. The content management server generates a visual representation of the content objects for user access. The transaction management server initiates a delivery transaction that generates a reference pointer to each of the content objects based on the user's inputs. The user initiates actions associated with the content objects using the reference pointer for acquiring the content objects. | 09-22-2011 |
20110239192 | FULLY DECLARATIVE BUILD SYSTEM FOR BUILD OPTIMIZATION - A fully declarative build system is described for software build optimization. The build system supports complete control over build and test inputs and build and test operations. The build system takes inputs from a source control system. The inputs can include source code files, test files and various site files used to generate human-oriented materials for the modules. A dependencies file specifies a set of dependencies among the modules of the system. When invoked, the build system determines that changes have been made to the inputs. The system then parses the dependencies file, and based on it, determines exactly which inputs will be affected by the changes. The build system can then rebuild only those modules that will be affected by the changes, as determined from the dependencies file. Alternatively, the system may only perform testing or document generating for files which are dependent on the modified file. | 09-29-2011 |
20110271252 | DETERMINING FUNCTIONAL DESIGN/REQUIREMENTS COVERAGE OF A COMPUTER CODE - A method that includes: running a set of functional tests over a computer code; determining, for each code element of the computer code, which functional test covered it, to yield a tests-elements coverage map; associating portions of the computer code with corresponding design portions or requirements derived from a design document or a requirements document respectively, associated with the computer code, to yield a design/requirements-code tracing map; deriving, from the tests-code coverage map and the design/requirements-code tracing map, a design/requirements-tests coverage map, exhibiting coverage of the computer code by the functional tests, in terms of the design or the requirements, wherein at least one of the running, the determining, the associating, and the deriving is executed by at least one processor. | 11-03-2011 |
20110271253 | ENHANCING FUNCTIONAL TESTS COVERAGE USING TRACEABILITY AND STATIC ANALYSIS - A method that may include: building a dependencies graph representing dependencies between code elements of a computer code; associating portions of the computer code with corresponding design specifications or requirements derived from a design specifications document or a requirements document respectively which is associated with the computer code, to yield a design specifications or requirements-code tracing map; and analyzing the design specifications or requirements-code tracing map based on the dependencies graph to yield an ordered list of design specifications or requirements respectively, wherein the order is selected such that functional tests written for the computer code and addressing design specifications or requirements of a higher order, will yield a higher level of functional test coverage of the computer code in terms of design specifications or requirements. | 11-03-2011 |
20110271254 | POLYPHASIC MODULES FOR SOFTWARE DEVELOPMENT - 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 associates classes of the software program with module declarations for a set of modules and uses the module declarations to manage dependencies in the software program throughout the life cycle of the software program. | 11-03-2011 |
20110289480 | METHOD AND APPARATUS FOR APPLICATION BUILDING USING BUILD STYLES - A method of building a software product in an integrated development environment using build styles. The method includes 1) applying a plurality of build styles, each of the build styles comprising a dictionary of build settings, to a target; 2) determining an order of precedence for the build styles and other dictionaries containing build settings; and 3) building a software product using said target and said build styles. The build settings within the build styles are capable of referring to other build settings and concatenating new values with previously defined values. | 11-24-2011 |
20110307863 | SYSTEM AND METHOD FOR AUTONOMOUS GENERATION OF SOFTWARE DOCUMENTATION - The disclosure relates generally to autonomous generation of software documentation, and more specifically to autonomous generation of documentation that describes user-defined rules implemented for a computer management system. In one embodiment, a system for generating documentation comprises a database storing user-defined rules that specify management actions to be triggered, for managing a computer system, responsive to receipt of a system message from the managed computer system. The system further comprises a documentation generation device configured to autonomously generate documentation describing the rules, wherein the documentation contains identification of at least the system message and the corresponding management actions triggered by the rules upon receipt of the system message. In certain embodiments, the system further comprises a database utility device configured to generate a highly-structured representation of the user-defined rules from an autoaction database, and the documentation generation device processes the highly-structured representation to autonomously generate the documentation. | 12-15-2011 |
20120005655 | METHOD AND SYSTEM FOR CREATING OWL ONTOLOGY FROM JAVA - A method, system, and computer program product are disclosed for creating an OWL ontology from a Java source code, wherein the Java source code includes a plurality of Java classes. Each of these Java classes includes one or more Java members and one or more Java objects. The Java objects are used to instantiate each of the Java classes. An OWL class is created for each of the Java classes, and an OWL concept is created for each of the Java members. Further, an OWL instance is created for each of the Java objects. Each of the OWL classes, the OWL concepts, and the OWL instances are assigned data type properties and object properties. Subsequently, each of the OWL classes and relations between them, each of the OWL concepts, and each of the OWL instances are included to form the OWL ontology. | 01-05-2012 |
20120072887 | GENERATING DEPENDENCY MAPS FROM DEPENDENCY DATA - Disclosed herein are techniques for generating data that describes dependencies between software components as transactions are processed, as well as displaying dependency maps based on the data. The data may be collected by agents that monitor or trace transactions being processed by the software components. The collected data may be aggregated to form a directed graph that describes the dependencies between the software components. A dependency map may be displayed based on the directed graph. The dependency map may show dependencies between software components as the transactions are processed. The dependency map may also show dependencies between applications that include the software components. The dependency map(s) may allow a user to easily and quickly ascertain where a problem is occurring. For example, the user might be able to quickly determine that a problem is at a backend database, as opposed to an application server at a frontend. | 03-22-2012 |
20120089963 | AUTOMATED ANALYSIS OF COMPOSITE APPLICATIONS - An application analysis mechanism analyzes a composite application for conformance to a set of component interaction rules that define one or more conditions that should be satisfied between components written in different languages, along with an action that is performed depending on the analysis of the conditions. Once the component interaction rules are defined, the composite application is received. Next, a model of the composite application is built that separates components of the composite application into categories based on the programming language used, and includes metadata to describe interaction between components. The set of component interaction rules is then run against the model of the composite application. The results of the analysis are then output. The automated analysis of composite applications removes much of the process that is prone to human errors to provide an efficient and consistent approach for analyzing composite applications. | 04-12-2012 |
20120102458 | GENERATING DOCUMENTATION FROM TESTS - A documentation system is described herein that automatically generates documentation for software code from tests that verify the correct operation of the software code. Software development teams often write automated tests (software that tests the software being shipped), such as unit tests. When written correctly, these tests are a written contract of what the software is supposed to do. The documentation system can use static and dynamic analysis in combination with annotations in the test code to extract the contract from these tests and leverage the extracted information to automatically generate the documentation. The system can then visually display this information in a textual or graphical way. Thus, the documentation system generates documentation that more accurately reflects how software code is expected to operate, without introducing significant burdens into the software development cycle. | 04-26-2012 |
20120124555 | Optimization of Compiled Control Objects - A method of optimizing a compiled control, for example a user interface control, includes generating a source code document including a test instruction statement that accesses an element of the control. The source code is then compiled, and one or more matched instructions in the compiled document are identified that correspond to the test instruction statement. A pattern is then formed using the one or more matched instructions. | 05-17-2012 |
20120159441 | RECOMMENDATION SYSTEM FOR AGILE SOFTWARE DEVELOPMENT - Methods and systems described herein implement a recommendation system for providing recommendations for generating a requirements specification for agile software development. In one implementation, the system includes a processor and a memory coupled to the processor. The memory comprises a mapping module and an agile recommendation module. The mapping module is configured to map knowledge elements of at least one ontology instance selected from among a plurality of ontology instances with another ontology instance selected from among the plurality of the ontology instances. The agile recommendation module is configured to generate a knowledge corpus based on the mapped knowledge elements of the ontology instances and at least one environmental parameter, receive modifications in the knowledge corpus, and provide recommendations to generate a requirements specification based at least, in part, on the received modifications. | 06-21-2012 |
20120159442 | AUTO-DOCUMENTING BASED ON REAL-TIME ANALYSIS OF CODE EXECUTION - Methods and systems for providing a monitoring center with sensors that are inserted at one or more locations within an operating framework software engine. The sensors monitor the interpretive framework engine's process of loading commands, combining variables with coded commands, and executing commands with event processing, variable values, and user interactions. The sensors watch and gather information that has been deemed relevant by the monitoring center's configuration and pass that information to the center so that storage functions can route the information to the appropriate data storage locations. Alternatively, each sensor can be self-contained providing monitoring, gathering, processing, data transmission, and storage within the sensor. | 06-21-2012 |
20120167049 | PARAMETERIZED INTERFACE IDENTIFIER TECHNIQUES - Interface identifier parameterization techniques are described. In one or more implementations, a textual description is obtained of a parametric type represented in a binary standard of a programming model and an interface identifier is generated based at least in part on the obtained textual description of the parametric type. | 06-28-2012 |
20120233595 | SERVICE DEFINITION DOCUMENT FOR PROVIDING BLENDED SERVICES UTILIZING MULTIPLE SERVICE ENDPOINTS - A service definition document (SDD) framework is provided for defining blended services that utilize multiple service endpoints. The SDD framework can comprise a first category that defines a service endpoint representing a blended service, a second category that defines a plurality of service endpoints utilized by the blended service, and a third category that defines execution of the blended service. Blended services can be provided by creating a model of a blended service and saving a representation of the model of the blended service in a service definition document (SDD) framework. A blended service defined in a SDD framework can be executed by receiving the SDD and executing the blended service as defined by the SDD using a service execution environment (SEE). | 09-13-2012 |
20120278789 | COMPUTER IMPLEMENTED APPARATUS FOR GENERATING AND FILTERING CREATIVE PROPOSAL - A computer implemented apparatus for automatically generating and filtering creative proposals is disclosed. Particularly, the computer implemented apparatus automatically generates all possible featured component code sets which corresponding to all possible featured components, and compares them to the prior art code sets which corresponding to the prior objects. Thereby, the novel code sets which corresponding to the novel creative proposals are rapidly filtered out. The computer implemented apparatus comprises a standard component database, a permutation and combination module, a featured component code set database, a prior art code set database, a matching module, a sifting module and an output module. | 11-01-2012 |
20120297364 | AUGMENTED DESIGN STRUCTURE MATRIX VISUALIZATIONS FOR SOFTWARE SYSTEM ANALYSIS - A design matrix structure visualization technique and tool for the study and analysis of systems, such as software systems, where the bounds of the matrix are defined by a selected focusing metric and entities forming the system are displayed in the matrix as blocks of size relative to their proportion of the selected focusing metric. Relationships between entities are illustrated by summing all relationships between individual elements forming each displayed entity. Where possible, an identifier defining the characteristic of a displayed block is also shown. Preferably, the technique and tool includes a “zoom” feature to allow a user to drill down and uncover details associated with smaller blocks as shown in the original view. | 11-22-2012 |
20120304153 | CONTEXT-SENSITIVE ANALYSIS FRAMEWORK USING VALUE FLOWS - In general, in one aspect, the invention relates to a method for identifying program properties in source code. The method includes: identifying a set of program objects corresponding to a potential program property within the source code; identifying a function associated with the set of program objects in the source code; identifying an input and an output of the function in the source code; creating a value flow graph by: creating a function input node representing the input; creating a function output node representing the output; identifying value flow functions, where each value flow function defines a conditional dependency between a pair of graph nodes, and creating, based on the value flow functions, directed graph edges modeling a potential flow of data through the value flow graph; and identifying a feasible path in the value flow graph depicting an occurrence of the potential program property in the source code. | 11-29-2012 |
20120311535 | STATIC SEMANTIC ANALYSIS OF DYNAMIC LANGUAGES - Analyzing dynamic source code. A method includes accessing a specific metadata format data structure. The data structure was created by obtaining one or more first data structures defining constructs in a body of dynamic language source code. From the one or more first data structures, identifier information is extracted for one or more of the defined constructs. Knowledge about the constructs is augmented. The metadata format data structure is parsed to compute metrics about the metadata format data structure. The metrics about the metadata format data structure are provided to a user. | 12-06-2012 |
20120311536 | STATICALLY DERIVED SYMBOLIC REFERENCES FOR DYNAMIC LANGUAGES - Creating metadata for dynamic code in a descriptive metadata language. The method includes obtaining one or more first data structures defining constructs in a body of dynamic language source code. From the one or more first data structures, identifier information is extracted for one or more of the defined constructs. Knowledge about the constructs is augmented. Metadata about the body of the dynamic language source code is provided, with the source code, in a specific metadata format, to a user. | 12-06-2012 |
20120324425 | AUTOMATIC CODE DECORATION FOR CODE REVIEW - The automated generation of code decoration for a body of code under review. Upon accessing the body of code, the system evaluates portions of the code for context. For at least some of those portions of code, the system identifies a decoration corresponding to that context, and adds the identified decoration to the body of code in a manner that the decoration is visually associated with the corresponding portion of the code. | 12-20-2012 |
20130042221 | SYSTEM AND METHOD FOR AUTOMATIC IMPACT VARIABLE ANALYSIS AND FIELD EXPANSION IN MAINFRAME SYSTEMS - A system and method for field analysis, in an organization is described herein. According to the present invention, the system parses the software code to prepare an abstract syntax tree, extract attributes and relational report, load the report in a common repository, perform impact analysis on the said common repository based on user provided seed, and prepare the list of impacted variables. Further, if required the impacted fields are expanded based on the target size information provided. | 02-14-2013 |
20130055203 | LOCATING ISOLATION POINTS IN AN APPLICATION UNDER MULTI-TENANT ENVIRONMENT - A computer implemented method for locating isolation points in an application under multi-tenant environment includes scanning, using a computer device an application by using scanning rules, to obtain potential isolation points and relationships between the potential isolation points; specifying at least one isolation point among the potential isolation points; and screening an isolation point from the potential isolation points by using relationships between the specified at least one isolation point and the remaining potential isolation points. | 02-28-2013 |
20130055204 | LOCATING ISOLATION POINTS IN AN APPLICATION UNDER MULTI-TENANT ENVIRONMENT - An apparatus for locating isolation points in an application under multi-tenant environment includes a scanning module configured to scan the application, by using scanning rules, to obtain potential isolation points and relationships between the potential isolation points; a specifying module configured to specify at least one isolation point among the potential isolation points; and an isolation point screening module configured to screen an isolation point from the potential isolation points by using relationships between the specified at least one isolation point and the remaining potential isolation points. | 02-28-2013 |
20130061209 | SYSTEMS AND METHODS FOR PROCESSING SOFTWARE APPLICATION METADATA ASSOCIATED WITH A SOFTWARE APPLICATION - Systems and methods for processing software application metadata associated with a software application are provided. A representative method includes the step of collecting software application metadata associated with a software application. The software application metadata includes a first set of information related at least one of the following: screens, paths, and layers associated with the software application. The method further includes the step of storing the software application metadata in a data repository. | 03-07-2013 |
20130067436 | ENHANCING FUNCTIONAL TESTS COVERAGE USING TRACEABILITY AND STATIC ANALYSIS - A method that may include: building a dependencies graph representing dependencies between code elements of a computer code; associating portions of the computer code with corresponding design specifications or requirements derived from a design specifications document or a requirements document respectively which is associated with the computer code, to yield a design specifications or requirements-code tracing map; and analyzing the design specifications or requirements-code tracing map based on the dependencies graph to yield an ordered list of design specifications or requirements respectively, wherein the order is selected such that functional tests written for the computer code and addressing design specifications or requirements of a higher order, will yield a higher level of functional test coverage of the computer code in terms of design specifications or requirements. | 03-14-2013 |
20130074039 | DETERMINING FUNCTIONAL DESIGN/REQUIREMENTS COVERAGE OF A COMPUTER CODE - A method that includes: running a set of functional tests over a computer code; determining, for each code element of the computer code, which functional test covered it, to yield a tests-elements coverage map; associating portions of the computer code with corresponding design portions or requirements derived from a design document or a requirements document respectively, associated with the computer code, to yield a design/requirements-code tracing map; deriving, from the tests-code coverage map and the design/requirements-code tracing map, a design/requirements-tests coverage map, exhibiting coverage of the computer code by the functional tests, in terms of the design or the requirements, wherein at least one of the running, the determining, the associating, and the deriving is executed by at least one processor. | 03-21-2013 |
20130080998 | EXTRACTING BUSINESS RULES OF A SERVICE-ORIENTED ARCHITECTURE (SOA) SYSTEM - The present disclosure discloses a method, system, and computer program product for extracting business rules of a Service-Oriented Architecture (SOA) system. Each of the method, system, and computer program product providing functions comprising: obtaining values of a plurality of business objects; obtaining structure units of the SOA system; establishing association relationships between the structure units and the values of the business objects; and generating business rules based on the association relationships. Using one or more embodiments of the present disclosure can break through the limitations of the conventional method of extracting business rules of a SOA system based on code, and can extract business rules of a complex SOA system. | 03-28-2013 |
20130086553 | SYSTEMS AND METHODS FOR FINDING PROJECT-RELATED INFORMATION BY CLUSTERING APPLICATIONS INTO RELATED CONCEPT CATEGORIES - A system, method, and computer-readable medium, is described that finds similarities among programming applications based on semantic anchors found within the source code of such applications. The semantic anchors may be API calls, such as Java's package and class calls of the JDK. Latent Semantic Indexing may be used to process the application and semantic anchor data and automatically develop a similarity matrix that contains numbers representing the similarity of one program to another. | 04-04-2013 |
20130091491 | Self-Documentation of Development Systems - The present disclosure involves systems, software, and computer implemented methods for providing self-documentation of development systems. One process includes operations for identifying at least one software component for deployment on a client device. An installation package is received from a source server, the installation package including the at least one software component and at least one artifact associated with the software component. Source documentation is generated for the at least one software component based on the at least one artifact. | 04-11-2013 |
20130198721 | VISUALIZATION OF INFORMATION USING LANDMASSES - The present invention relates to the visualization of complex information using a set of navigable landmasses. A method for generating a visualization of a programming code base using a set of navigable landmasses in accordance with an embodiment of the present invention includes: representing each of a plurality of different code components using a respective landmass; adjusting a size of each landmass based on a number of lines of code in the code component corresponding to the landmass; and displaying the landmasses. | 08-01-2013 |
20130205279 | METHODS AND APPARATUS FOR ANALYZING SOFTWARE INTERFACE USAGE - Methods and apparatus for analyzing the interface usage and requirements within software applications. In one embodiment, the interfaces comprise application programming interfaces (APIs) used with Java-based software, and the apparatus comprises a computer program that analyzes file paths (or classpaths) containing one or more files comprising Java bytecode. The names of the classes are extracted and placed into a class dictionary. The different classes listed in the dictionaries are broken down into their individual methods. Each method is then dissembled and analyzed for method or field invocations on other classes found in the dictionary. Methods called are added to a “used class” report. The used class report preferably contains the name of the class, method and the instruction information. | 08-08-2013 |
20130212563 | Method and a System for Searching for Parts of a Computer Program Which Affects a Given Symbol - The present invention relates to a method and system for searching for parts of a computer program which affects a given symbol. The system comprises a first data storage area ( | 08-15-2013 |
20130219362 | DESIGN RULE HIERARCHY, TASK PARALLELISM, AND DEPENDENCY ANALYSIS IN LOGICAL DECISION MODELS - A binary augmented constraint network (BACN) allows dependency relationships to be determined without solving constraints. BACN models design decisions as first-class members and expresses how decisions make assumptions upon each other using logical constraints. Pairwise dependency relations (PWDRs) are determined based on the BACN. A design rule hierarchy (DRH) based on assumption relations among design decisions identifies parallelizable tasks within software design. Modules within the same layer of the hierarchy suggest concurrent tasks. Dependencies between layers or within a module suggest possible need for communication. In one configuration, decisions within the top layer of the hierarchy are the most influential design rules, which dominate the rest of the system, and are kept stable. The decisions within subsequent layers assume design decisions in previous layers. The design decisions within each layer are clustered into modules. Modules within the same layer are independent from each other and are candidates for concurrent implementation. | 08-22-2013 |
20130239090 | Visual Representations of Code in Application Development Environments - A device can implement a stage view depicting a visual element for each of a plurality of components of an application under development. The device implements a code overlay showing whether code can be applied to the components and, for components to which code can be applied, a code status indicator. The status indicator may relate to procedural code or to a data member, such as an object or other variable. Different indicators can be used to show that code can be applied, code is applied correctly, incomplete code is applied, or code is applied but contains an error. Different colors or other visual effects can be used to indicate status. The indicators may be selectable to provide a code viewing or editing interface. A status indicator for code associated with a component can be positioned near the visual representation of the component, but may be repositionable. | 09-12-2013 |
20130254743 | Method For Automatic Extraction Of Designs From Standard Source Code - A system and method for automatic code-design and file/database-design association. Existing source code is analyzed for process and control elements. The control elements are encapsulated as augmented state machines and the process elements are encapsulated as kernels. The new elements can then have meta-data attached (including, a name, I/O method, and test procedures), allowing software code sharing and automatic code/file/database upgrading, as well as allowing sub-subroutine level code blocks to be accessed directly. | 09-26-2013 |
20130254744 | System and Method to Select Compatible Open-Source Software and Components for Developed or Conceptualized Solution - The present invention relates to a system and method for verifying the compatibility among the software components used in the software solution using an auto-license compatibility verifier. Further, the present invention provides the method for enabling the auto-license compatibility verifier, a tool for automatically and dynamically mapping the licensing information of the software components which are used in the software solution with respect to the already stored licensing information which are stored in the database. | 09-26-2013 |
20130268916 | 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. | 10-10-2013 |
20130275944 | SYSTEMS AND METHODS FOR EXPRESSING TEMPORAL RELATIONSHIPS SPANNING LIFECYCLE REPRESENTATIONS - Techniques for expressing temporal relationships between lifecycle representations are provided. For example, one computer-implemented technique includes obtaining two or more lifecycle representations of at least two components of at least one computing system, annotating the two or more lifecycle representations with at least one temporal relationship, and storing the two or more annotated lifecycle representations as at least one deployment descriptor, wherein the at least one deployment descriptor is useable for managing the at least one computing system. In another computer-implemented technique, at least two internal lifecycle models of at least two components of at least one computing system are analyzed, at least one temporal relationship that exists between the at least two components are analyzed, and the at least one temporal relationship is transformed into at least one sequence of change management operations for use in managing the at least one computing system. | 10-17-2013 |
20130326481 | SYSTEM AND METHOD FOR TRACKING SOFTWARE PACKAGE DEPENDENCIES USING A GRAPH MODEL - Methods and systems for generating a graph model associated with a software release. The methods and systems are configured to receive a software release including a set of software packages. The software release is parsed to identify modeling information including package information, package dependency information, and function dependency information associated with each software package in the set of software packages. A graph model is generated and stored which represents the modeling information, wherein the graph model comprises a package node for each software package in the set of software packages and a function node for each function in the set of software packages. | 12-05-2013 |
20130326482 | ANNOTATING A GENERATOR OUTPUT STREAM - A method for automatically and transparently annotating document source code, the method including: receiving an output stream produced by a source code of a generator; wrapping the output stream to produce a copy of the output stream; automatically annotating the copy with source information, wherein the source information maps a relationship between data in the output stream and the source code of the generator; and storing the source information on a memory device. | 12-05-2013 |
20130332903 | SYSTEM AND METHODS FOR DETERMINING DECOMPOSITION GRAPH COMPLEXITY - A method for generating a decomposition graph having an effective cyclomatic complexity measure below the McCabe limit for a decomposition level, includes the steps of determining the number of processes and/or objects within the decomposition level, determining a cyclomatic complexity measure based on the number of processes and/or objects within the decomposition level, determining a number of dimensions required to display the decomposition level such that the cyclomatic complexity does not exceed the McCabe limit, and generating the decomposition graph based on the determined number of dimensions required to display the decomposition level. | 12-12-2013 |
20130332904 | SYSTEM AND METHOD FOR AUTOMATIC DETECTION OF DECOMPOSITION ERRORS - A system and method for detecting decomposition errors in a parallel processing software design having at least two decomposition levels, where each decomposition level has at least one process. The system and method further identifies improper control flow, looping structure and/or dataflow within the software design and restructures the software design to remove any improper elements. | 12-12-2013 |
20140013304 | SOURCE CODE ANALYTICS PLATFORM USING PROGRAM ANALYSIS AND INFORMATION RETRIEVAL - In one embodiment, a code analytic platform may use a novel combination of information retrieval and program analysis techniques to develop a code relationship graph | 01-09-2014 |
20140019937 | UPDATING PRODUCT DOCUMENTATION USING AUTOMATED TEST SCRIPTS - Techniques are disclosed for generating and updating product documentation. The techniques include monitoring a script being executed to test the functionality of an application. The script may have one or more tags associated with corresponding tags in documentation associated with the application. The techniques further include capturing, during execution of the script, content items from the application based on the one or more tags of the script and inserting the captured content items into the documentation at locations indicated by the corresponding tags of the documentation. | 01-16-2014 |
20140019938 | METHOD AND APPARATUS FOR JUDGING NECESSITY OF PERFORMING INTEGRATION TEST - Whether or not an integration test between or among software components is necessary is judged. Corresponding information between features is acquired, which configures a feature model expressing characteristics of a group of products produced by the software product line, and a type and variations of each software component. For each software component, a set of state variables of all of the features corresponding to the software components is produced based on the corresponding information. For each software component, a specific logical formula is produced. Two or more software components are designated. A necessity judgment formula is produced by logical-product combining all the specific judgment formulas, for the software components designated. It is judged that the integration test is necessary when the necessity judgment formula always shows FALSE (inconsistent formula) and not necessary when the necessity judgment formula shows unclearness as to TRUE or FALSE, or always shows TRUE (valid formula). | 01-16-2014 |
20140033173 | Generating Layouts for Graphs of Data Flow Applications - An embodiment of the invention provides a method of displaying a data flow, wherein a description of a data flow application to be displayed is received. The data flow application includes nodes and edges connecting the nodes, wherein the nodes represent operators and the edges represent data connections for data flowing between the operations. A reason that a user is to view the data flow and/or a user constraint on a complexity of the data flow application to be displayed is determined with a processor; and, the time required to render a display of the data flow application is estimated. A transformed representation of the data flow application is created with the processor. The transformed representation is created based upon the user reason, the user constraint, the estimated time of rendering, and/or a layout strategy. The transformed representation is displayed on a graphical user interface. | 01-30-2014 |
20140040863 | DOCUMENTATION GENERATION FOR WEB APIS BASED ON BYTE CODE ANALYSIS - Documentation for an application or web service, such as a web application programming interface (API), is generated by analyzing bytecode for the application itself. Metadata contained within the bytecode and that specifies the functionality of the web service is extracted and used as a template and basis for documentation. A second source of documentation, which contains detailed documentation of the web service, is contributed by the web service developer and merged with the metadata extracted from the bytecode. | 02-06-2014 |
20140082590 | SYSTEM AND METHOD OF RECONSTRUCTING COMPLEX CUSTOM OBJECTS - A system and method is provided for reconstructing one or more collections of objects across platforms. More particularly, Java Annotations are used to assist a Web Services Description Language (WSDL) wizard in reconstructing a collection of objects. In implementation, the system and method parses the object types such that a wizard can recreate or reconstruct the collection of objects for use by a receiving service. The method includes reconstructing a collection using one or more annotations that document a base object of the collection. | 03-20-2014 |
20140089898 | USING MULTIPLE TECHNICAL WRITERS TO PRODUCE A SPECIFIED SOFTWARE DOCUMENTATION PACKAGE - An embodiment of the invention produces software documentation that includes first and second sections. Skills a technical writer needs are determined, wherein preparation of the first and second sections require different skill sets. A database is searched to select technical writers qualified to prepare each of the multiple document sections, wherein the database contains the identities and qualifications of persons qualified to be technical writers. Preparation of the first and second sections are then assigned to first and second writers having first and second skill sets, respectively. Each prepared section is validated for incorporation into the software documentation. | 03-27-2014 |
20140101638 | AUTOMATIC GENERATION OF INSTRUCTION-SET DOCUMENTATION - A method and system for the automatic generation of user guides. Specifically, the method of the present invention includes accessing an abstract processor model of a processor, wherein said abstract processor model is represented using a hierarchical architecture description language (ADL). The abstract processor model includes a plurality of instructions arranged in a hierarchical structure. An internal representation of the abstract processor model is generated by flattening the abstract processor model. The flattening process generates a plurality of rules grouped by common convergent instructions. Each rule describes an instruction path through the hierarchical structure that converges at a corresponding convergent instruction. An instruction-set documentation is automatically generated from the plurality of rules, wherein the instruction-set documentation is arranged convergent instruction by convergent instruction. | 04-10-2014 |
20140109048 | METHOD AND SYSTEM TO AUTOMATICALLY GENERATE USE CASE SEQUENCE DIAGRAMS AND CLASS DIAGRAMS - A system and computer-executed method automatically generate a sequence diagram from Class-Responsibility-Collaborator (CRC) information. The CRC information identifies objects, responsibility information for each object, and collaborator information for each object, and the CRC information corresponds with each activity in an activity diagram. The method includes storing, in a storage device, the objects and corresponding class types of the objects according to the CRC information and associating, by a processor, each of the objects with one or more other objects according to the collaborator information of the CRC information. The method also includes determining, by the processor, messages from each of the objects to associated objects according to the responsibility information, and the processor automatically generating the sequence diagram including the objects and the messages among the objects. | 04-17-2014 |
20140109049 | CODE QUALITY IMPROVEMENT - Techniques enabling an end-user to specify complex concepts consisting of code abstractions, design abstractions and architectural abstractions in rule form are disclosed. In one embodiment, a graphical user interface is provided to guide a user through the process of entering concept specification information in order to define concepts, including the provision of one or more code snippets that are subsequently analyzed to assist the user in specifying the concept. The resulting rules or concept signatures are evaluated by a rule engine to determine the degree to which the underlying concepts are reflected in a given set of code. Recommended measures that need to be taken for transforming code to satisfy a concept may be provided subsequent to the analysis of the code. In this manner, code quality may be improved through systematic analysis of targeted code to demonstrate adherence (or non-adherence, as the case may be) to user-defined concepts. | 04-17-2014 |
20140115563 | DIFFERENTIAL STATIC PROGRAM ANALYSIS - Systems for program analysis include a high-level scanning tool configured to perform a high-level analysis on a program using a processor to generate one or more high-level findings; one or more low-level scanning tools, each configured to perform a low-level analysis on the program using a processor to generate a low-level finding; and a mapping module configured to map the one or more low-level findings to the high-level findings to generate a concise combination report that categorizes each finding according to the highest-level analysis that produces the finding. | 04-24-2014 |
20140123107 | SYSTEMS AND METHODS TO MAINTAIN CONSISTENCY BETWEEN SOFTWARE SPECIFICATION AND CODE - A method and a system to maintain consistency between software specification and code arc described. A specification engine converts a specification describing features included, in apiece of software into convened specification that describes the historical details of the features organized temporally. A code engine abstracts code corresponding to the specification into a design. An n-trace engine traces a portion of the converted specification that describes a particular feature of the one or more features to a portion of the design that includes the code that, when executed by one or more processors, implements the particular feature and generates a time-graph that sequentially orders events occurring in connection with the portion of the code. | 05-01-2014 |
20140123108 | SYSTEMS AND METHODS FOR ESTIMATING AN IMPACT OF CHANGING A SOURCE FILE IN A SOFTWARE - The technique relates to a system and method for estimating an impact of changing one or more source files in a software based on a clone dependency graph. This technique involves extracting the source files from a repository and detecting code cones present in the source files. After detecting the code clones the clone dependency graph is created. Several graph metrics are calculated and applied to the clone dependency graph to estimate the impact of changing a source file on other source files of the software. Finally, the output is visualized with the help of graph visualization technique. | 05-01-2014 |
20140137081 | INDICATING HIERARCHY DIVERSION IN A CLASS DIAGRAM - Indicating hierarchy diversion in a class diagram. A class inheritance structure for at least one parent class contained in computer program code can be identified to determine a class hierarchy corresponding to the parent class. For at least one child class in the class hierarchy that is a child of the parent class, a parent-child similarity value corresponding to a parent-child diversion of the child class from the parent class can be calculated via a processor. The class diagram can be generated. The class diagram can indicate at least the parent class, the child class and the parent-child similarity value. The class diagram can be presented. | 05-15-2014 |
20140165038 | ANALYSIS OF PROPAGATED INFORMATION USING ANNOTATED FORESTS - Annotation information associated with entities of a computing system can be added to a forest generated from the entities where the structure of the forest reflects relationships between the entities. Annotations associated with a child node can be propagated to all parent nodes of the child node all the way up to one or more root nodes of the annotated forest. Annotations associated with a child node can be propagated to a specified depth or place or at nodes with one or more particular characteristics or annotations. The propagation can be performed on-demand to all or some subset of nodes. The annotated forest can be analyzed to determine nodes to which a set of conditions apply. | 06-12-2014 |
20140165039 | Methods for detecting plagiarism in software code implementing a design pattern - Methods and instructions embodied in non-transitory media for the detection of plagiarism in software code implementing a design pattern are described. Steps involved may include receiving input comprising the software code at least one design pattern implemented in the software code, identifying at least one function call to a function in a class implementing the design pattern in the software code, and creating a representation of the called function in the class containing the function call, wherein the function call and the function to which it corresponds is characteristic of the design pattern; and where the created representation implements program logic associated with at least one function implementing the design pattern, including the called function. The function call may be replaced with the representation of the called function. Additionally, the modified code may then be compared with one or more target files. | 06-12-2014 |
20140173561 | ASSOCIATION OF METADATA WITH SOURCE CODE AND APPLICATIONS AND SERVICES PREMISED THEREON - Systems and methods are described that enable metadata to be associated with source code at various levels of granularity (e.g., at the level of files, classes, functions, lines, statements and expressions) and that enable such metadata to be accessed independently of the source code with which it is associated. Such metadata may be used to track provenance and history of source code within and across source code repositories, associate ratings or other indicia of quality or reliability with source code, wherein such ratings may be exposed to developers and wherein such ratings may be used to better manage the automated check-in, testing and analysis of source code, and facilitate a process by which a component that manages a source code entity is notified about updates made to a related source code entity and by which like changes may be to the source code entity in a manual or automated fashion. | 06-19-2014 |
20140173562 | Automatic Documentation Generator - The subject matter disclosed herein provides methods and apparatus, including computer program products, for generating a list of object descriptions based on an object's relevance for documentation. In one aspect there is provided a method that may include accepting a setting for a filter and a setting for a flag of an object. The filter setting may represent a type of information to be included in a list of object descriptions. The flag setting may represent a category of documentation relevance for the object that may be stored in a repository. The method may include comparing the filter setting with the flag setting of the object, extracting the description of the object from the repository based on the comparing of the flag setting with the filter setting, and generating the list of object descriptions that includes a description of the object. Related systems, apparatus, methods, and/or articles are also described. | 06-19-2014 |
20140173563 | EDITOR VISUALIZATIONS - Methods, systems, and computer program products are provided for inferring the programming intent of code developers to suggest code solutions. Program code is retrieved from a code repository that includes program code generated by a plurality of code developers. The program code is analyzed to determine one or more program code design patterns. A knowledge set is generated that includes the determined program code design pattern(s), and that is network-accessible by software development applications to provide program code suggestions for developing software programs. | 06-19-2014 |
20140208296 | API Usage Pattern Mining - Techniques for mining API method usage patterns from source code are described. These techniques include parsing the source code to generate API method call sequences that include an API method. These call sequences are clustered to obtain clusters. Based on the clusters, frequent closed sequences are determined and then clustered to obtain an API usage pattern. In addition, optimal clustering parameters may also be determined. In some instances, a graphical representation is generated based on the API usage pattern in response to a query associated with the API method. | 07-24-2014 |
20140215437 | HIGH PERFORMANCE INTERCONNECT PHYSICAL LAYER - A serial data link is to be adapted during initialization of the link. Adaptation of the link is to include receiving a pseudorandom binary sequence (PRBS) from a remote agent, analyzing the PRBS to identify characteristics of the data link, and generating metric data describing the characteristics. | 07-31-2014 |
20140215438 | DICTIONARY-BASED DEPENDENCY DETERMINATION - Techniques are described herein for performing a dictionary-based dependency determination. For example, when a package is selected to be imported from a store (e.g., a database), a dictionary-based dependency operation may be performed to determine which elements of the package are dependent on other elements of the package. A dictionary includes indexes, each of which has at least one value. The indexes correspond to respective resources, and each value indicates an element of the package that produces the resource that corresponds to the respective index. If an element of the package consumes a resource, the indexes and corresponding values in the dictionary may be reviewed to determine which element(s) of the package produce that resource. | 07-31-2014 |
20140223415 | METHOD FOR MODELING SOURCE CODE HAVING CODE SEGMENTS THAT LACK SOURCE LOCATION - A system and method for modeling code segments that do not have a location is disclosed. Source code may be indexed and modeled in a data graph with nodes representing code elements and edges representing relationships between nodes. However, some code elements may be hidden or implicit and therefore may lack location information. In these cases, code figments are created and represented as nodes in the graph. Figment nodes may be specially designated so that the figment nodes may be easily distinguished from real source code nodes. The graph is then updated to include location information for the code figments in the nodes that interact with the hidden or implicit code. The data graph may then be provided to a user or as a service to be used by coding tools. | 08-07-2014 |
20140223416 | SYSTEM AND METHOD FOR DOCUMENTING APPLICATION EXECUTIONS - An information processing system, computer readable storage medium, and method for documenting the execution of long running applications. A processor of the information processing system operates to continuously collect snapshots monitored from an executing application on a runtime system. The processor selects, based at least on user specified policies, collected snapshots that indicate a significant change in runtime behavior of the executing application on the runtime system. The processor annotates each of the selected snapshots with description of the significant change in runtime behavior of the executing application. The processor operates to store and update documentation of an execution history of the executing application from the annotated snapshots. | 08-07-2014 |
20140223417 | PROGRAM LOGIC FOR SPECIFYING THE REQUIREMENTS PLACED ON A DEVELOPMENT RESULT - The invention relates to a program logic for specifying and documenting requirements placed on a development result, wherein several individual requirements are recorded and stored with their mutual relationships in form of a graph. In order to enable documentation of all requirements placed on a development result with respect to complete content and independent of the user's expert knowledge it is proposed that templates for individual requirements associated with at least one development result are stored, a similarity value between at least one of the already recorded individual requirements and the stored requirement templates is calculated, and requirement templates are provided with a similarity value disposed in a predetermined range for individual requirements to be newly recorded, are adjusted thereto and are stored as additional requirements placed on the development result. | 08-07-2014 |
20140237449 | SYSTEM AND METHOD FOR AN OBJECT INSTANCE ACQUIRER - A method, computer program product, and computer system for receiving, at a computing device, an input including an indication of a type of an object for which an instance is required. Code that is declared in a software development application is scanned for the instance. An output is generated including one or more suggestions how to acquire the instance based upon, at least in part, the code that is declared in the software development application. | 08-21-2014 |
20140282401 | COMPOSITE PROGRAM HISTORY - A system and methods are disclosed for maintaining a composite history of changes to a program comprising two parallel histories. In accordance with one embodiment, a computer system identifies a first history of changes to a program, and generates a second history of changes to the program based on the first history, where the second history has a final version of the program that is identical to a final version of the program in the first history, and where the second history excludes changes to the program in the first history that introduce an error that is fixed in a subsequent change to the program in the first history, and where the second history includes all other changes to the program in the first history. The computer system then generates a third history of changes to the program that comprises the first history and the second history. | 09-18-2014 |
20140282402 | SYSTEMS AND METHODS FOR CONTROLLING BRANCH LATENCY WITHIN COMPUTING APPLICATIONS - Systems and methods for controlling branch latency within computing applications including a development framework, a visual design subsystem, and a deployment subsystem, where at runtime the deployment subsystem is operable to implement out-of-band signaling mechanism such that components notify downstream components of accumulated branch latency so that downstream components can implement appropriate buffering techniques. | 09-18-2014 |
20140282403 | SYSTEM FOR GENERATING READABLE AND MEANINGFUL DESCRIPTIONS OF STREAM PROCESSING SOURCE CODE - An information processing system, computer readable storage medium, and method for automatically generating human readable and meaningful documentation for one or more source code files. A processor of the information processing system receives one or more source code files containing source code artifacts (SCA) and infers semantics therefrom based on predefined rules. The processor, based on the inferred semantics, extracts documentation from another source code file. The extracted documentation and the inferred semantics are used to generate new human readable and meaningful documentation for the SCA, such new documentation being previously missing from the SCA. The generated new documentation is included with the SCA in one or more source code files. | 09-18-2014 |
20140282404 | APPLICATION DISCOVERY AND INTEGRATION USING SEMANTIC METAMODELS - A metamodel selector may determine a semantic metamodel for at least two software applications, the semantic metamodel including a description of semantics, processes, and data that are applicable to the at least two software applications. A metadata manager may determine application metadata describing an application of the at least two applications. A transformation engine may transform the application metadata into an application-specific metamodel instance of the semantic metamodel, and an integration engine may integrate the at least two software applications, based on the application-specific metamodel instance. | 09-18-2014 |
20140289704 | METHODS, SYSTEMS AND COMPUTER-READABLE MEDIA FOR DETECTING A PARTIAL COMMIT - The present invention provides a method and system for detecting a partial commit of software. A dependency information of the software is extracted from a version history and a bug database. A dimensional matrix containing a set of commit, and relationship information with a set of files with each commit is created from the dependency information. A centrality matrix is computed by performing a first set of matrix transformations on the dimensional matrix. A set of missing files of a partial commit, is identified by performing a second set of matrix transformations on the centrality matrix and a file vector, the file vector including a file dependency information of the partial commit. | 09-25-2014 |
20140289705 | Systems and Methods for Generating Function-Relation Call Trees - Systems and methods are provided for generating a function-relation call tree. For example, an externally-specified global variable name is acquired; whether a first function matches the externally-specified global variable name is inquired; in response to the first function matching the externally-specified global variable name, whether a code of the first function includes a branch-judgment code is determined; in response to the code of the first function including the branch-judgment code, the code of the first function is divided to acquire a pre-branch-judgment code, a branch-judgment code and a post-branch-judgment code; the branch judgment code is analyzed to determine whether a related function is called by a code section associated with an attribute value of the branch-judgment code; and in response to the related function being called by the code section associated with the attribute value of the branch-judgment code, a function-relation call tree between the code section associated with the attribute value and the related function is generated. | 09-25-2014 |
20140298294 | System and Method for Analyzing Software Application in View of Entry Points - The present disclosure provides a system and method for performing an analysis of a software application in a computing environment. A receiving module accepts source code of the software application as input data and obtains a list of the entry points. Intermediate representation from the input data is generated in order to construct informative structure for the software application. Uncalled functions in the software application are identified and are considered as entry points. The entry points are wrapped into one entry point and analyzed maintaining calling context of all the entry points. | 10-02-2014 |
20140310688 | USING STACK DATA AND SOURCE CODE TO RANK PROGRAM CHANGES - A computer accesses a stack data and a source code of a program. The computer searches for a first change made to the program, wherein the first change is one of a change to a method of the program, a change to a class of the program, a change to a method that is invoked by the program, or a change to a class containing a method that is invoked by the program. The computer identifies the first change that was made to the program and determines the probability that the identified first change caused one or both of an error and a regression. The computer generates a ranked list of identified changes based, at least in part, on the probability that the identified first change caused one or both of an error and a regression. | 10-16-2014 |
20140310689 | System And Method For Embedding Symbols Within A Visual Representation Of A Software Design To Indicate Completeness - A system and method for quickly discerning a process's completeness via graphical representation of processes by graphical objects with associated embedded symbols is disclosed. The present system and method decreases design time and increases personnel deployment efficiency. | 10-16-2014 |
20140331202 | Software Analysis Program and Software Analysis System - To easily specify a difference part among multiple source codes even in the case of software that is relatively large scaled and complicated as an embedded system, and to make it possible for an area of influence that the difference part has to be easily understood. In a software analysis system of an embedded system into which a computer system is embedded, the software analysis system has a similarity measurement part that treats a dependence relationship in the source code controlling the embedded system as a graphical structure and measures a similarity of one or more source codes, and an image display unit for displaying the similarity. | 11-06-2014 |
20140337820 | SOURCE CODE FLOW ANALYSIS USING INFORMATION RETRIEVAL - According to an example, source code flow analysis may include receiving source code for an application, and identifying virtual flow documents for the application from the source code. The virtual flow documents may represent ordered sequences of method calls for the application. The source code flow analysis may further include extracting features of the virtual flow documents, determining similarity between the virtual flow documents by estimating similarities for the extracted features to determine a flow-to-flow similarity, and clustering the virtual flow documents based on the flow-to-flow similarity. The flow-to-flow similarity may be further used, for example, to generate highest priority virtual flow documents and methods for the source code. The source code flow analysis may also include determination of flow-to-maintenance activity description (MAD) similarity, for example, to identify relevant virtual flow documents from the virtual flow documents based on the flow-to-MAD similarity to generate ordered relevant virtual flow documents. | 11-13-2014 |
20140344783 | SYSTEMS AND METHODS FOR FINDING PROJECT-RELATED INFORMATION BY CLUSTERING APPLICATIONS INTO RELATED CONCEPT CATEGORIES - A system, method, and computer-readable medium, is described that finds similarities among programming applications based on semantic anchors found within the source code of such applications. The semantic anchors may be API calls, such as Java's package and class calls of the JDK. Latent Semantic Indexing may be used to process the application and semantic anchor data and automatically develop a similarity matrix that contains numbers representing the similarity of one program to another. | 11-20-2014 |
20140359577 | SYSTEMS AND METHODS FOR FINDING CONCURRENCY ERRORS - Systems and methods for detecting concurrency bugs are provided. In some embodiments, context-aware communication graphs that represent inter-thread communication are collected during test runs, and may be labeled according to whether the test run was correct or failed. Graph edges that are likely to be associated with failed behavior are determined, and probable reconstructions of failed behavior are constructed to assist in debugging. In some embodiments, software instrumentation is used to collect the communication graphs. In some embodiments, hardware configured to collect the communication graphs is provided. | 12-04-2014 |
20140366003 | System and Method for Identifying and Valuing Software - A system and method for identifying and valuing software is realized by use of a logical structures-to-functions (LSF) model with steps for creating LSF sequences and storing them in a data storage medium for querying. Number and types of lowest abstract functional components and order of flow of logical data processing of each computer program algorithm of the computer program are identified. Components of each algorithm are coded into a sequence of characters for preserving information of the order of flow of data processing and number and types of components. The sequence is stored in a data storage medium. The data storage medium is queried to compare the sequence of characters, for its respective computer program algorithm, to general population sequences, of other computer program algorithms, to find similarities and differences in structural and functional data processing. | 12-11-2014 |
20140380276 | CLASS AND NAMESPACE DISCOVERY IN PROTOTYPE BASED LANGUAGE - Structure of a prototype-based programming language program is determined based on results of program execution. The structure determined can be implied by a program rather than explicitly declared. For example, classes and namespaces of a prototype-based program can be detected or inferred by identifying patterns that indicate the presence of a class or namespace. Furthermore, members of classes and namespaces can also be determined. | 12-25-2014 |
20150012910 | VIRTUAL OPERATING AREA SUPPORTING CUSTOMIZED DEFINITION AND OPERATING METHOD AND SYSTEM ARCHITECTURE THEREOF - A virtual operating area supporting customized definition, and an operating method and system architecture thereof that enables a user to configure a business service operating environment according to user's requirements, so as to form multiple service operating environments oriented to different requirements. Multiple virtual operating areas, related function tools thereof, and supporting platforms are formed into software architecture, operating methods, and a system device of a business information system. In the solution, by using a system building method based on a group of concepts, comprising ‘virtual operating area’, ‘share’, ‘tool’, ‘data’, ‘interactive room’, and so on, that are comprehensible to ordinary users, a user can quickly master a method for building a virtual operating area oriented software system, and can build a processing environment suitable for ‘working’, and process services according to a procedure familiar to the user. | 01-08-2015 |
20150033204 | SYSTEM-CONSTRUCTION-PROCEDURE GENERATING DEVICE, SYSTEM-CONSTRUCTION-PROCEDURE GENERATING METHOD, AND PROGRAM THEREOF - A construction procedure of a system which is constructed by performing operations of plural types with respect to each of plural program modules is generated. A system-construction-procedure generating device ( | 01-29-2015 |
20150040105 | SYSTEM AND/OR METHOD FOR COMPUTING INTERPROCEDURAL DOMINATORS - According to an aspect of some embodiments of the present invention there is provided a computerized method of analyzing code of a software program for dominance relationships between a plurality of functions of the software program, the method comprising: receiving source code of a software program, the source code having a plurality of functions; identifying a plurality of intraprocedural dominator graphs each for another of the plurality of functions; combining the plurality of intraprocedural dominator graphs to create an interprocedural dominance graph with edges that logically connect between nodes of the plurality of functions; identifying a plurality of interprocedural dominance relations between nodes in different functions of the plurality of functions using the interprocedural dominance graph; and analyzing the software program according to the plurality of interprocedural dominance relations. | 02-05-2015 |
20150058822 | SYSTEM AND METHOD FOR ESTIMATING IMPACT OF SOFTWARE UPDATES - A system and method of estimating impact of software updates includes obtaining usage measures for an instance of a software application, analyzing the software update of the software application by comparing base code for the software application to updated code for the software application, identifying one or more lines of interest from the base code based on the comparing, and aggregating the usage measures for the instance associated with the lines of interest to determine an impact factor. The base code corresponds to source code for the instance. The updated code corresponds to source code for the software application after the software update is applied to the base code. In some examples, the system and method further include normalizing the impact factor based on a length of time used to collect the usage measures, a number of lines of code in the base code, and a number of lines of code in the updated code. | 02-26-2015 |
20150067644 | METHOD AND APPARATUS FOR MINIMUM COST CYCLE REMOVAL FROM A DIRECTED GRAPH - Implementations of the present disclosure involve a system and/or method for minimum cost cycle removal from a directed graph. The system determines if a provided graph contains any cycles by assigning each vertex an integer value and comparing the integer values of vertices connected by an edge. When the value of a starting vertex is greater than an ending vertex, a cycle is present. The system then determines which edges may be removed in order to minimize the cost of breaking the cycle. The system generates a linear cost function that is equal to the sum of a cost to remove an edge multiplied by a corresponding binary variable. Constraints are generated to ensure that the result does not have any cycles. The system then solves for the minimum of the linear cost function by utilizing the constraints. The value of the binary variables may then be used to determine which edges to remove. | 03-05-2015 |
20150067645 | METHOD TO GENERATE DYNAMIC CUSTOMIZED CONTEXT-SENSITIVE HELP - Embodiments of the present invention disclose a method, computer program product, and system for customizing help screens. A computer receives a request for help content. The computer identifies an annotated help file that corresponds to the request for help content. The computer identifies one or more variables in the identified annotated help file. The computer retrieves a value for each of the one or more variables from a software product. The computer replaces each of the one or more variables in the identified annotated help file with the retrieved value to generate customized help content. | 03-05-2015 |
20150082278 | CLONE DETECTION METHOD AND CLONE FUNCTION COMMONALIZING METHOD - A clone detection method including a detection step of detecting at least a plurality of subsystems, functions of which can be commonalized, from a model constituted by a block diagram and having a plurality of subsystems each composed of an input port, an output port, and a block connected between the input port and the output port, the detection step being performed by a control section. | 03-19-2015 |
20150089477 | UNDERSTANDING COMPUTER CODE WITH HUMAN LANGUAGE ASSISTANCE - Methods and arrangements for providing human-language descriptors for computer code. An interface is used to input computer code, and a human-language descriptor is automatically associated with at least one code identifier in the computer program code, wherein the human-language descriptor is obtained to assist a user in determining a meaning of the at least one code identifier. The human-language descriptor is visually displayed along with the at least one code identifier. Other variants and embodiments are broadly contemplated herein. | 03-26-2015 |
20150089478 | SYSTEMS AND METHODS FOR EXTRACTING CROSS LANGUAGE DEPENDENCIES AND ESTIMATING CODE CHANGE IMPACT IN SOFTWARE - The technique relates to a method, device, and non-transitory computer readable medium for extracting cross language dependencies and estimating code change impact in software based on a plurality of dependency graphs, a network of the plurality of co-committed files and one or more predefined graph metrics. This technique involves extracting source code and revision history data from repository for construction of plurality of dependency graphs and a network of plurality of co-committed files in order to determine one or more cross language dependencies and code change impact in software system built using multiple programming languages, by analyzing the dependency graphs, the network of co-committed files and one or more predefined graph metrics. Finally, the output is visualized with the help of one or more graph visualization technique. | 03-26-2015 |
20150143339 | CALLPATH FINDER - Techniques and systems for creating a function call graph for a codebase are disclosed. Graph creation includes identifying functions in the codebase by a function signature and representing a function as a first node in the call graph. For that function, identifying call-to functions, call-from functions, and inheritance parents and children, and a base class from the function signature of that function; adding child nodes to the first node based on the identified call-to and call-from functions; for an interface call to a base class method in the function, adding child nodes to the first node based on implementations of an override of the base class method; for an added child node, removing that child node from the first node if a source file that includes an implementation of an override and a source code file that includes the function don't share at least one common binary file. | 05-21-2015 |
20150149983 | 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. | 05-28-2015 |
20150317156 | Systems and Methods for Automated Generation of Interactive Documentation Based on Web Application Description Language Files - In a method of generating documentation for a computing interface, an interface description file that includes a machine-readable description of a computing interface is parsed. Elements of the interface description file are identified according to a template file responsive to the parsing thereof, and an output file that includes human-readable documentation for the computing interface is automatically generated from the elements identified in the interface description file. Related devices and computer program products are also discussed. | 11-05-2015 |
20150324194 | METHOD FOR MODELING SOURCE CODE HAVING CODE SEGMENTS THAT LACK SOURCE LOCATION - A system and method for modeling code segments that do not have a location is disclosed. Source code may be indexed and modeled in a data graph with nodes representing code elements and edges representing relationships between nodes. However, some code elements may be hidden or implicit and therefore may lack location information. In these cases, code figments are created and represented as nodes in the graph. Figment nodes may be specially designated so that the figment nodes may be easily distinguished from real source code nodes. The graph is then updated to include location information for the code figments in the nodes that interact with the hidden or implicit code. The data graph may then be provided to a user or as a service to be used by coding tools. | 11-12-2015 |
20150347128 | SYNCHRONIZING COMMENTS IN SOURCE CODE WITH TEXT DOCUMENTS - Various embodiments synchronize comments in a source code file with text of a source code document. In one embodiment, a source code document is compared to a corresponding source code file. The source code document comprises a set of text corresponding to a set of source code comment text in the corresponding source code file. The source code document is configured to display the set of text in a stylized format when presented to a user. The set of text in the source code document is determined to be different than the set of source code comment text in the source code file based on the comparison. At least the set of source code comment text in the source code file is automatically changed based on the set of text from the source code document and in response to the determination. | 12-03-2015 |
20150347129 | ASSIGNING AN ANNOTATION TO A VARIABLE AND A STATEMENT IN A SOURCE CODE OF A SOFTWARE APPLICATION - Disclosed is a method and system for assigning an annotation to a statement in a source code. The method comprises generating intermediate representation of the source code by parsing the source code. The method comprises identifying one or more instances of definition of a variable and one or more instances of use of the variable. The method comprises categorizing the variable into a group of variables based on the one or more instances of definition of the variable, the one or more instances of use of the variable, a description of the variable, and mathematical operators defining a correlation between the variable and one or more other variables. Further, a data description table and a data dictionary of the plurality of variables are created. The method assigns an annotation to the variable present in the statement of the source code based on the data description table and the data dictionary. | 12-03-2015 |
20150355903 | VISUALIZATION OF CODE UNITS ACROSS DISPARATE SYSTEMS - A visualization tool that provides visibility of the functionality implemented with each system used by an institution(s) at code unit granularity can be used to overcome a variety of challenges that can occur in an environment with disparate systems. The visualization tool discovers and graphically displays functions/procedures/methods (“code units”) that satisfy a set of one or more criteria, as well as attributes of the discovered code units. Furthermore, the visualization tool can automatically provide visual annotations to identify targets for asset maintenance, targets to leverage for other systems, etc. | 12-10-2015 |
20150355904 | PROGRAM VISUALIZATION DEVICE, PROGRAM VISUALIZATION METHOD, AND PROGRAM VISUALIZATION PROGRAM - A data visualization device includes a module for a specific viewpoint which is selected and a diagram representing the program is generated for modules included in source code. For a module extracted using a module call relationship diagram creation unit, a data analysis unit calculates the relevance of a viewpoint, which is input by a user, by utilizing a module call relationship and a common data usage relationship. The relevance is calculated by multiplying the viewpoint relevance of a viewpoint dependent module serving as the base point and a viewpoint relevance weight in an action determination table and in inter-module path viewpoint relevance weight data. The calculated viewpoint relevance is corrected using a viewpoint relevance correction value in viewpoint relevance determination noise correction threshold data. Final viewpoint relevance is stored into per-module viewpoint relevance determination data and a program diagram in accordance with this viewpoint relevance is created. | 12-10-2015 |
20150363196 | Systems And Methods For Software Corpora - Systems, methods, and computer program products are shown for providing a corpus. An example embodiment includes automatically obtaining a plurality of software files, determining a plurality of artifacts for each of the plurality of software files, and storing the plurality of artifacts for each of the plurality of software files in a database. Additional embodiments determine some of the artifacts for each of the software files by converting each of the software files into an intermediate representation and determining at least some of the artifacts from the intermediate representation for each of the software files. Certain example embodiments determine at least some of the artifacts for each of the software files by extracting a string of characters from each of the plurality of software files. The software files can be in a source code or a binary format. | 12-17-2015 |
20150370556 | ESTABLISHING SUBSYSTEM BOUNDARIES BASED ON CALL FLOW GRAPH TOPOLOGY - According to one exemplary embodiment, a method for establishing subsystem boundaries is provided. The method may include receiving an input program having a plurality of subroutines and at least one inter-subroutine call. The method may include generating a graph having a plurality of nodes and at least one edge, wherein the at least one edge includes a first end connected to a first node and a second end connected to a second node. The method may include assigning an edge weight to the at least one edge wherein the edge weight is based on a number of second ends received by the second node. The method may include determining, based on the assigned edge weight, a distance value between each pair of nodes. The method may include generating a grouping of nodes based on the determined distance value between each pair of nodes. | 12-24-2015 |
20150378724 | IDENTIFYING CODE THAT EXHIBITS IDEAL LOGGING BEHAVIOR - Techniques are described for identifying the ideal or preferred logging behavior to be followed in a software development project. A numerical weight is computed for each method in the source code that can be used to rank the logging behavior of that method. The numerical weight is computed in such a way that the methods whose log printing statements have been modified more frequently receive higher numerical weights. The assumption is that since most logging enhancements are done as after thoughts during code reviews or while fixing bugs, the ideal logging behavior will be exhibited by those methods whose logging behavior was modified the most frequently. Once the methods have been ranked according to the numerical weight, the highest ranking methods can be used to provide insight to developers about the ideal logging behavior for the project. | 12-31-2015 |
20160011868 | SOFTWARE DOCUMENTATION GENERATION WITH AUTOMATED SAMPLE INCLUSION | 01-14-2016 |
20160019056 | Techniques for Automatically Identifying Input Files Used to Generate Output Files in a Software Build Process - Techniques for automatically identifying input files used to generate output files in a software build process are provided. In one embodiment, a computer system can execute one or more build commands for generating output files for a software product, where the software product is associated with a build tree comprising various input files. The computer system can further intercept system calls invoked during the execution of the one or more build commands and can collect information pertaining to at least a portion of the intercepted system calls. The computer system can then create a dependency graph based on the collected information, where the dependency graph identifies a subset of input files in the build tree that are actually used by the one or more build commands to generate the output files. | 01-21-2016 |
20160026461 | SYSTEMS AND METHODS FOR AUTOMATIC API DOCUMENTATION - Systems, methods, and articles of manufacture provide for automatic API documentation. | 01-28-2016 |
20160034258 | System and Methods of Generating Build Dependencies Radiator - A method of generating an information radiator indicating module dependency relationships includes retrieving a collection of modules forming an application program from an integration server; determining in the collection a plurality of base modules and one or more modules dependent on an output of each base module; and displaying on a web page a dependency layout of the collection of modules, the dependency layout based upon a plurality of dependency relationships between each of the determined plurality of base modules and the one or more modules dependent on the output of each base module. | 02-04-2016 |
20160034275 | CODING CONVENTION DISCOVERY AND ENFORCEMENT - In general, embodiments of the invention provide an approach to discover and enforce coding conventions among a group of developers. Specifically, source code files for a group of developers are imported from a code repository. The source code files are analyzed to discover the commonly used coding conventions of the group. Convention templates are generated based on these coding conventions. Each convention template is assigned a weighted value, and the convention templates are reviewed and approved based on the weighted value. | 02-04-2016 |
20160041824 | REFINING DATA UNDERSTANDING THROUGH IMPACT ANALYSIS - In an approach for refining data for an impact analysis, a computer receives a selection of source code and impact analysis criteria, wherein the impact analysis criteria includes at least a time frame. The computer determines a subset of the selected source code, the subset within a time frame specified by the selected impact analysis criteria. The computer returns results based on the selected impact analysis criteria, wherein the results include the subset of the selected source code. | 02-11-2016 |
20160062767 | DESIGN ANALYSIS OF DATA INTEGRATION JOB - A request for analysis of a data integration job is received that includes one or more features and criteria for the analysis. Each feature is extracted from a job model representing the job by invoking a corresponding analytical rule for each feature. The analytical rule includes one or more operations and invoking the analytical rule performs the operations to analyze one or more job components associated with the corresponding feature as represented in the job model and to extract information pertaining to that feature. | 03-03-2016 |
20160085546 | Source Code Separation and Generation for Heterogeneous Central Processing Unit (CPU) Computational Devices - An example method includes obtaining annotated source code and based at least in part on a first annotation, separating the source code into first and second source code portions. The method also includes generating from the first source code portion a first source code stream to be supplied for compilation by a first compiler, the first source code stream augmented, based on the first annotation, to include additional coordination code not present in the obtained source code, and the first compiler specific to the first-type subset of the target CPUs. The method further includes generating from the second source code portion a second source code stream to be supplied for compilation by a second compiler, the second compiler specific to a second-type subset of the target CPUs. The target CPUs of the first- and second-type subsets have one or more different functionalities. | 03-24-2016 |
20160098272 | SYSTEM AND METHOD FOR VISUALIZING SOFTWARE PROGRAMS - A system and a method for visualizing a software program are provided. The system is configured to store the software program and its change logs. The system is further configured to generate a visualization structure of the software program according to at least one of Data Clumps information, Divergence Change information and Shotgun Surgery information, and display the software program according to the visualization structure. The method is applied to the system to implement the operations. | 04-07-2016 |
20160110186 | SYSTEMS AND METHODS FOR FINDING PROJECT-RELATED INFORMATION BY CLUSTERING APPLICATIONS INTO RELATED CONCEPT CATEGORIES - A system, method, and computer-readable medium, is described that finds similarities among programming applications based on semantic anchors found within the source code of such applications. The semantic anchors may be API calls, such as Java's package and class calls of the JDK. Latent Semantic Indexing may be used to process the application and semantic anchor data and automatically develop a similarity matrix that contains numbers representing the similarity of one program to another. | 04-21-2016 |
20160162289 | TRANSITIVE SOURCE CODE VIOLATION MATCHING AND ATTRIBUTION - Methods, systems, and apparatus, including computer programs encoded on computer storage media, for matching and attributing code violations. One of the methods includes receiving a plurality of snapshots of a code base, including data representing a revision graph of the snapshots of the code base and data representing respective violations in each of the plurality of snapshots. A plurality of transitively matched violations in the code base are generated, wherein each transitively matched violation represents a respective sequence of matching violations from a first violation of a first snapshot to a second violation of a second snapshot, wherein each transitively matched violation identifies a respective first violation representing an initial occurrence of a coding defect in the code base and a respective second violation representing a last occurrence of the coding defect in the code base | 06-09-2016 |
20160188297 | REQUIREMENTS CONTRADICTION DETECTION SYSTEM, REQUIREMENTS CONTRADICTION DETECTION METHOD, AND REQUIREMENTS CONTRADICTION DETECTION PROGRAM - To determine a contradiction between requirements and specifications in a specification document for system/software development without labor for preparation in advance, provided is a requirements contradiction detection system, including: a relevancy detection part for detecting, for two requirements expressed in texts, a relevancy between the two requirements based on a similarity between one requirement acquired by converting one of the texts based on a predetermined contradiction rule and another requirement that is not converted; and a contradiction detection part for detecting whether or not the two requirements contradict each other based on a detection result of the relevancy detection part, the similarity calculated by the relevancy detection part, and a similarity between the two original requirements before conversion. | 06-30-2016 |
20160202970 | MAINTENANCE TOOLKIT FOR THE IMPLEMENTATION OF COMPUTER PROGRAMS | 07-14-2016 |
20160378464 | DATA EXTRACTION AND GENERATION TOOL - An item to be processed is received and scanned. The scan identifies any functions or procedures in the item being processed, and extracts actual code representing those functions or procedures. Any invoking functions, which invoke the identified function, are, themselves, identified. Actual code for the invoking function is extracted as well. An output documentation file is generated that includes a name of the identified function or procedure, as well as actual code for the function or procedure, and actual code from at least one example of an invoking function. | 12-29-2016 |