Entries |
Document | Title | Date |
20080201688 | SYSTEM AND METHOD FOR THE AUTOMATIC VERIFICATION OF PRIVILEGE-ASSERTING AND SUBJECT-EXECUTED CODE - The present relates to a method for verifying privileged and subject-executed code within a program, the method further comprising the steps of constructing a static model of a program, identifying checkPermission nodes that are comprised within the invocation graph, and performing a fixed-point iteration, wherein each determined permission set is propagated backwards across the nodes of the static model until a privilege-asserting code node is reached. The method further comprises the steps of associating each node of the invocation graph with a set of Permission allocation sites, analyzing each identified privilege-asserting code node and subject-executing code node to determine the Permission allocation site set that is associated with each privilege-asserting code node and subject-executing code node, and determining the cardinality of a Permission allocation-site set that is associated with each privilege-asserting code node and subject-executing code node. | 08-21-2008 |
20080209389 | Method, System and Program Product Supporting Sequential Encoding for Relational Analysis (SERA) of a Software Model - A method of verifying a software system includes receiving a description of a software system described utilizing a high-level modeling language, and responsive thereto, parsing the description and constructing an abstract syntax graph. The abstract syntax graph is transformed into a sequential logic representation of the software system, and following the transforming, the software system is verified based upon the sequential logic representation. Following verification, results of verification of the software system are output. | 08-28-2008 |
20080209390 | Pluggable model elements - Various technologies and techniques are disclosed for providing pluggable model elements. A modeling application is provided that is operable to allow custom model elements to be loaded. Custom behavior can be associated with the custom model element types in a modular fashion that allows custom behaviors to be plugged in. The modeling application interacts with an artifact mapper to automatically synchronize a particular model in the modeling application with an underlying one or more artifacts represented by the particular model. Events are intercepted between model elements and underlying artifacts that the model elements represent. As events are intercepted, one or more appropriate provider plug-ins are called to perform one or more associated actions. A user who toggles between a modeling application and an artifact source application is provided with a seamless viewing experience because the model elements and underlying artifacts are kept up to date with each other. | 08-28-2008 |
20080216050 | Method and System for Accessing a Resource Implemented in a Computer Network - The present invention relates to method and system for accessing a resource implemented in a computer network, wherein a plurality of different runtime environments exist used by either one of the resources or by a systems management application accessing one of the resources, wherein the different runtime environments require the usage of a web service resource framework comprising a plurality of respective different, runtime-specific web service standards. | 09-04-2008 |
20080229275 | Method and system for process composition - A method and system for model composition. A business process model defined by a plurality of tasks may be accessed. A plurality of available executable elements capable of implementing the plurality of tasks may be identified. Each of the plurality of available executable elements may be capable of providing functionality to implement parts of the business process model. One or more executable elements may be selected among the plurality of available executable elements for each of the plurality of tasks. The selection may be based on functionality of an available executable element. The selected elements may be combined for the plurality of tasks to create an executable process for the business process model. | 09-18-2008 |
20080229276 | AUTOMATIC COMPOSITION OF MODEL TRANSFORMATIONS - Techniques for composition of model transformations from a predetermined set of model transformations. A state machine is provided in memory. The states are defined in the state machine in terms of predetermined model attributes. In response to specification of a target state for an input model to be transformed, an execution sequence in the state machine, between a start state corresponding to the input model and an end state corresponding to the specified target state, is selected. Each transformation in the selected sequence is then successively executed on the input model. After executing each transformation in the selected sequence, the transformed input model state is compared to the model state defined in the state machine to determine if the selected sequence is inoperable for the input model. If so, an alternative execution sequence in the state machine, between the input model state and the specified target state, is selected. | 09-18-2008 |
20080229277 | DATA LOCATIONS TEMPLATE BASED APPLICATION-DATA ASSOCIATION AND ITS USE FOR POLICY BASED MANAGEMENT - Method and system are disclosed for automatically discovering associations between applications and data in multi-tiered distributed systems. The method in one aspect uses a machine-readable specification of a model or template that describes use and transformation of data by software components. The method additionally utilizes a model of system configuration and appropriate runtime support to mine information available from systems management software present in enterprise systems. The application-data association discovery process performs a traversal of the distributed system configuration graph with actions taken during this traversal driven by the contents of the templates for the software components present in the system. The results of the application-data association discovery process are stored in a database and may be used to specify application-specific information lifecycle management (ILM) policy or as input to impact analysis tools in access control and antivirus systems. | 09-18-2008 |
20080235654 | Using collaborative development information in a team environment - Various technologies and techniques are disclosed that provide and interact with a collaborative development information store in a team software development environment. A submission service updates an active meta-model of an application in a central information store that is used by multiple users. A notification service operating in a particular software development environment receives notice that changes have been made to the active meta-model. Information received from the notification service is then used to update a display in the particular software development environment. On the database server, a reception service is provided that receives active meta-model information of the application being developed by the multiple users as the information changes. A storage service is provided to store the received active meta-model information in a specific relational database structure that is operable to allow artifacts to be added without alteration to the specific relational database structure. | 09-25-2008 |
20080235655 | Method of designing a system comprising hardware and software components - The invention relates to a method of designing a system. The system includes an application having software components and an architecture having hardware components on which the application is run. The system has to satisfy at least one functional and one non-functional requirement. The functional analysis step ( | 09-25-2008 |
20080235656 | METHOD AND APPARATUS FOR MASHING UP WEB APPLICATIONS - Disclosed are a method, apparatus, and computer program, product for mashing up web applications. The method includes: obtaining at least two document object models (DOM) corresponding to at least two web applications respectively; merging nodes of the at least two document object models to obtain a new document object model; connecting, on the new document object model, the nodes belonging respectively to the at least two document object models; and obtaining a new web application from the new document object model after connection. | 09-25-2008 |
20080250387 | Client-agnostic workflows - The subject mater herein relates to computer software and client-server based applications and, more particularly, to client-agnostic workflows. Some embodiments include one or more client-agnostic workflow application interaction models and one or more device specific transformation services. Some such embodiments provide one or more of systems, methods, and software embodied at least in part in a device specific transformation service to transform client-agnostic application interaction models, including models of workflows, to and from device or device surrogate specific formats. | 10-09-2008 |
20080256508 | Hybrid Spreadsheet/Workflow Design and Execution Environment - The present invention provides a user-friendly visual programming and modeling environment with a spreadsheet interface. The invention allows the creation of complex software applications and programs in real-time. A user with no programming skills can easily develop software programs. A hybrid workflow diagram and execution environment is created using a spreadsheet. The workflow and the spreadsheet cause variables in the spreadsheet cells to be manipulated. The hybrid workflow design and execution environment are used to implement computer readable code to create new executable software applications. | 10-16-2008 |
20080263506 | Analytical Software Design System - An analytical software design system arranged to receive informal system design specifications and to convert them into verified design specifications for use in creating source code and carrying out implementation testing of the source code is described. The system comprises a verified black box specification generator arranged to process the received informal system design specifications to create formal specifications; to generate from the formal specifications mathematical models representing the system behaviour; to analyse the mathematical models to determine if they have the required behaviour; to adjust the formal specifications until the required behaviour is achieved; and to derive the required verified design specifications from the mathematical models. | 10-23-2008 |
20080263507 | ACTION-BASED IN-PROCESS SOFTWARE DEFECT PREDICTION SOFTWARE DEFECT PREDICTION TECHNIQUES BASED ON SOFTWARE DEVELOPMENT ACTIVITIES - An action-based in-process software defect prediction (ABDP) applies classifying records of a performed action to predict whether subsequent actions cause defects in a project. A performed action is previously defined herein as an operation performed based on tasks in Work Breakdown Structure (WBS) of the project. Rather than focusing on the reported defects, ABDP discovers the patterns of the performed action that may cause defects composing a historic data set, and uses analytical results to predict whether the subsequent actions are likely to generate defects composing another historic data set. Once actions with high probability of causing the defects are identified, stakeholders review these actions carefully and take appropriate corrective actions to create a fresh performed action. The fresh performed action is continually appended to the historic data sets of amending the defects to construct a new prediction model for further subsequent actions. | 10-23-2008 |
20080263508 | Name-based identifiers of model elements - Embodiments of the present invention pertain to implementation of textual names as the actual identifiers of elements of models. A structured system provided for constructing the textual names so as to be unique in a specific context. In one embodiment, namespaces are added to a name as a mechanism for ensuring uniqueness across multiple development sources. In one embodiment, upon deployment to a runtime environment, alternate names are assigned to support efficient processing. | 10-23-2008 |
20080263509 | METHOD AND APPARATUS FOR APPLICATION PATTERNS AND APPLICATIONS GENEARATION - A method and apparatus for defining and creating generic context-related application patterns, and for defining and creating specific applications based on the application patterns. The method and apparatus include defining generic user interface preferably through interfacing specific environments, and content retrieval preferably through interfacing specific systems, such as enterprise systems. The application development then uses the generated patterns, and the specific user-interface and content retrieval components for developing a specific application. | 10-23-2008 |
20080263510 | APPARATUS AND METHOD FOR SUPPORTING MODEL-DRIVEN DEVELOPMENT - In a model editing apparatus, a model transformation function transforms SM (source model) | 10-23-2008 |
20080263511 | SYSTEM AND METHOD FOR SOFTWARE DELIVERY - A computer system and method for software delivery that include articles of manufacture having two or more installed, functional software applications organized in a protoset, the protoset configured to enable creation of one or more subsets (also called reduced metasets) from the two or more installed, functional software applications, each of the one or more subsets configured to be operable with a predefined computer system independent of the protoset; and a protoset module configured to operate on the protoset to enable creation of the one or more subsets of the two or more installed, functional software applications, the module responsive to one or more requests for the creation of the one or more reduced metasets. | 10-23-2008 |
20080270972 | METHODS FOR TYPE ANALYSIS IN SYSTEMS FOR CODE GENERATION - A method for identifying a structure of a type to generate a model of the type includes the step of providing at least one replacement type for a basic type provided by a programming language. An identification of initialization, by a constructor, of an instance of the at least one replacement type is received. A type model comprising a description of a data layout of the instance of the type is generated responsive to the received identification. | 10-30-2008 |
20080270973 | DERIVING GROUNDED MODEL OF BUSINESS PROCESS SUITABLE FOR AUTOMATIC DEPLOYMENT - A business process ( | 10-30-2008 |
20080270974 | Enterprise JavaBeans Metadata Model - A method and system to construct Java representations of metadata in an enterprise application. The system extracts metadata from application source code and deployment descriptors to construct a single output available to the application. | 10-30-2008 |
20080270975 | Method and System for Modeling and Naming a Software Class - A method for modeling classes to create an application in an object-oriented programming environment based on a hierarchical rooted classification (E) and inheritance-based naming of an entity is disclosed. The method comprising in the logic classification (EB), on a first level, determining whether the entity belongs to a single-element class (EBU) or a multiple-element class (EBG) and providing a first indication therefor; on a second level, if the entity belongs to a single-element class (EBU), determining whether the entity is one of a data (I), a link (L), a role (R) and a domain (D) and providing a second indication therefor; and creating a name for the entity by aggregating the first and the second indications. A method for modeling classes also based on exemplary class assembly models for behavior such as group, role and transaction is also disclosed. There is also disclosed a method for creating pseudo-code comprising: creating classes according to the method for modeling classes as disclosed above; creating a class assembly model for each model/package-group class; assembling said classes into package-group classes according to said model/package-group classes; and creating pseudo-code from said classes. | 10-30-2008 |
20080282220 | Model Elements in Software Tools as Automatons in a Software Customization System and Method - Presented is a system and method for the integration of existing software development tools into a software customization system, where each software development tool has its own model of its software artifacts. The invention allows models in an external software development tool to become software artifacts within a software customization system, and also allows the model elements of the existing tools to become automatons. | 11-13-2008 |
20080288915 | Determining destinations of a dynamic branch - A method, a translator, and a computer-readable medium for translating compiled programming code from a first code state to a second code state are disclosed. The programming code in the first state has a plurality of basic blocks, where each basic block has a set of instructions. At least one basic block ends in a dynamic branch, the dynamic branch being a transfer to one of a set of destinations based on a calculation of a destination address. The plurality of basic blocks in the first state of the programming code are identified, as are links between the identified basic blocks. A control flow graph (CFG) of the programming code is then constructed based on the identified basic blocks and identified links, where the CFG is in a preliminary form. At least one basic block ending in a dynamic branch is identified, and all identified basic blocks that lead to the dynamic branch are explored, based on the CFG, as far back as is necessary to fully determine a set of destination addresses for the dynamic branch. The set of destination addresses defines the set of destinations from the dynamic branch. Such set of destinations is examined to identify a branch table, and the CFG is updated to reflect the set of destinations and the identified branch table. The programming code is then translated from the first state to the second state based at least in part on the updated CFG. | 11-20-2008 |
20080295066 | Programming model for modular development - Various technologies and techniques are disclosed for providing a programming model for modular development. A definition feature is provided that allows a definition to be specified for a particular method that is part of an application. A production feature allows a functionality implementation to be specified for the particular method separately from the definition. A consumption feature allows a method call to be made indirectly to the functionality implementation of the particular method by referencing the definition of the particular method from a consuming method. The consuming method has no awareness of the functionality implementation for the particular method. An analysis process inspects components containing indirect associations between these consumers and producers of application functionality to generate a graph of direct associations between the consumers and producers without having to actually load the components. A loader process uses the graph of direct associations to run the application. | 11-27-2008 |
20080295067 | Flexible Access To Metamodels, Metadata, and Other Program Resources - A system and method for enabling a Meta Object Facility (MOF) and a Java Metadata Interface (JMI) compliant service to access program resources. A system includes a metamodel repository and an application server. The metamodel repository is configured to store the program resources including metadata and one or more metamodels. The application server includes at least one application providing a first portion of the program resources. A first portion of the program resources are stored in a database associated with the application server. A second portion of the program resources are provided in at least one application of the application server, and programming language instances of the program resources are received by one or more applications independent of where the program resources are stored or provided. | 11-27-2008 |
20080295068 | METHOD AND APPARATUS FOR FRAME-BASED KNOWLEDGE REPRESENTATION IN THE UNIFIED MODELING LANGUAGE (UML) - According to an embodiment of the present invention, there is provided a method and system for emulating a knowledge representation in a Unified Modeling Language (UML) environment. A Meta-Object Facility metamodel and UML profile are grounded in a foundation ontology. The elements representing the knowledge representation ontology are mapped to elements of UML, based on the grounded Meta-Object Facility metamodel and UML profile, thereby emulating the knowledge representation in a UML environment. | 11-27-2008 |
20080301625 | SYSTEM AND METHOD FOR CREATING AND UPDATING A DATA MODEL FROM DISPARATE EVENTS RECEIVED ON ARBITRARY APPLICATION THREADS - An abstract component model can be used to drive an editor by providing an underlying stateful model for component implementation without the need to re-implement details, such as event listening, lifecycle and update management, etc. An implementation needs to provide objects that make up the model, some logic to listen to environmental changes and recognize when an update is needed, and a builder which can generate a lightweight version of the model based on the current “state of the world.” In addition, abstract component model is operable to support an editor such as page flow. | 12-04-2008 |
20080301626 | TEMPLATE-BASED SOFTWARE DEVELOPMENT - A computer-implemented method for software development includes selecting a pre-defined software pattern, the pre-defined software pattern having one or more pre-defined elements, identifying one or more of the pre-defined elements to be modified, obtaining one or more behavioral models, each of the behavioral models specifying a functional behavior for at least one of the identified elements, ascertaining a modification required for each of the identified elements to provide the specified functional behavior, and incorporating the modification into an instance of the software pattern. | 12-04-2008 |
20080307384 | SEF PARSER AND EDI PARSER GENERATOR - A SEF grammar is created to be used with the Java CC program to autogenerate a SEF parser. The SEF parser can be run with specially written X12 code on any SEF file to automatically create an EDI object model for that SEF file. A programmer can then write application code to use the EDI object model to parse an EDI document that the SEF file describes and generate in memory an EDI object model instance for that EDI document. The application code is also used to employ the EDI object model instance to efficiently process the EDI document's EDI transaction. In addition, the application code is used to employ the EDI object model on the EDI object model instance to emit an EDI document for further use. | 12-11-2008 |
20080313599 | METHOD, SYSTEM AND COMPUTER PROGRAM FOR DEVELOPING SOFTWARE APPLICATIONS WITH INCREASED MODULARITY - A solution is proposed for developing software applications on a data processing system. A corresponding method (A | 12-18-2008 |
20080313600 | BI-DIRECTIONAL PROJECTION - In an embodiment, one or more computer-readable media holding executable instructions is provided. The instructions may be executed on a processing device to project a specification to a platform environment that includes a system model. The media may hold one or more instructions for accessing an algorithm model, the algorithm model being associated with the specification. The media may further hold one or more instructions for projecting the specification to the system model via a forward projection. The media may hold one or more instructions for receiving a reverse projection that includes specification changes, the specification changes identifying suggested changes to the specification. The media may further hold one or more instructions for modifying the algorithm model based on the specification changes, and the media may hold one or more instructions for storing the modified algorithm model. | 12-18-2008 |
20090007056 | Process extension wizard for coherent multi-dimensional business process models - This disclosure relates to methods, systems, and software for processing a coherent multi-dimensional business process model. The software includes computer-readable instructions embodied on media to identify a coherent multi-dimensional business process model based on at least a portion of a first model for a business process and at least a portion of a second model for the business process. The software then parses the multi-dimensional business process model to identify at least one extension point, each extension point operable to interface a disparate business tool with the business process. The software is further operable to present an extension wizard to a client for a particular one of the identified extension points. It can create entities and extensions in various modeling environments and development environments. | 01-01-2009 |
20090007057 | Object model for transactional memory - Various technologies and techniques are disclosed for providing an object model for transactional memory. The object model for transactional memory allows transactional semantics to be separated from program flow. Memory transaction objects created using the object model can live beyond the instantiating execution scope, which allows additional details about the memory transaction to be provided and controlled. Transactional memory can be supported even from languages that do not directly expose transactional memory constructs. This is made possible by defining the object model in one or more base class libraries and allowing the language that does not support transactional memory directly to use transactional memory through the object model. | 01-01-2009 |
20090007058 | Methods and apparatus for automation of register maps - In one aspect, a software application for facilitating design of a register specification is provided. The application comprises an interface adapted to receive input from a user indicating information about at least one register in the register specification, the interface generating register information based on the received input, a translator coupled to the interface to receive the register information and adapted to convert the register information to an internal representation, and at least one filter adapted to transform the internal representation into at least one respective output format. | 01-01-2009 |
20090007059 | Computer Method and Apparatus for Improving Programming Modeling With Lightweight Stereotypes - Computer method and apparatus provides lightweight stereotypes in a programming model. An alternative to applied profiles is disclosed. A keyword list or list of strings is recorded as an annotation to a model element. The keywords are indicative of applied stereotypes of the model element, where the stereotypes are empty or are used as labels. The list of strings effectively augments the collection of applied stereotypes of the model element. | 01-01-2009 |
20090013305 | GENERATING A SUBSET MODEL FROM A MODEL - A technique for identifying a minimum number of model elements associated with a model for generating a subset model of the model that includes receiving a model, a set of model elements and a set of dependency types associated with the model; assigning a collector component to each of the received model elements; locating a model element dependent on the received model element by one of the received dependency types; receiving from each collector a dependent model element, and for each dependent model element, determining whether the dependent model element has been collected by another collector with the same dependency type and updating a subset model list with the collected dependent model element to build a list of collected dependent model elements for generating a subset model in response to a negative determination. | 01-08-2009 |
20090024979 | Method and system for configuring a user interface - A method and system are provided for configuring a user interface to a user role. A user model defines one or more user roles and one or more tasks, each user role being linked to: one or more user tasks via one or more user goals, and a set of skills a user performing the role must have, wherein each task is also linked to one or more skills. A software product defines one or more software functions, and means are provided for linking each user task to a sequence of software function calls. The system includes an organization modeling tool including means for customizing the user model dynamically to alter the user role to task mapping to meet the current needs of an organization including validating the goals and sets of skills of the user model. The system also includes a display structure model including means for configuring a user interface to a user role, the display structure model being a runtime component for dynamically building control menus for groups of tasks depending on the user role of the logged on user. | 01-22-2009 |
20090024980 | USER INTERFACES AND SOFTWARE REUSE IN MODEL BASED SOFTWARE SYSTEMS - In a model based software system, a set of business rules is scanned, and patterns are identified. The patterns are then compared, and similarities identified which indicate that software can be reused in the system. In one embodiment, identifiers of the rules are scanned. In another embodiment, usage patterns are used for designing a middle layer and generating code. In another embodiment of the invention, a data model is generated by capturing data from a user interface for a business document. | 01-22-2009 |
20090031279 | APPARATUS, SYSTEM, AND METHOD FOR HIDING ADVANCED XML SCHEMA PROPERTIES IN EMF OBJECTS - An apparatus, system, and method for hiding advanced XML schema properties in EMF objects. XML Schema may comprise both user-defined properties and internal properties related to the structural features of the schema. The present invention hides the internal properties from clients while still keeping them available such that a complete XML Schema model can be generated, but without exposing a client to the non-intuitive internal properties. An SDO implementation leverages EMF implementation artifacts to present a client with an SDO API exposing user-defined properties and metadata describing user-defined properties. The SDO implementation further provides an extended API through which a client may access internal properties and metadata describing the internal properties. The invention further accounts for both dynamic SDO objects and static SDO objects. | 01-29-2009 |
20090031280 | Method for Generating an Executable Workflow Code from an Unstructured Cyclic Process Model and Method for Executing a Workflow Code of an Arbitrary Process Model - A method for generating an executable workflow code from an unstructured cyclic process model comprises the following steps. First, the unstructured cyclic process model is transformed into a preliminary workflow code. Then, from the preliminary workflow code the executable workflow code is generated by eliminating unstructured cycles. | 01-29-2009 |
20090049422 | METHOD AND SYSTEM FOR MODELING AND DEVELOPING A SOFTWARE APPLICATION - A method and system for modeling and developing software applications. Modeling and developing a programmatic interface includes defining an application framework with property, behavior and event elements, creating enabling services and system entities each including at least one element, listing the enabling services and system entities themselves as elements, providing a user interface that enables a user to define business entities, include such entities among the elements, and define relationships among entities created by the user and the elements, and generating a software application that provides the programmatic interface. | 02-19-2009 |
20090064089 | System and Method for Autonomic Software Price Variation Via Application Virtualization and Streaming Technology - The present invention provides a system and method for autonomic software price variation for virtualized applications of a computer program. The system includes a virtualization module that divides a software application into a plurality of discrete chunks an autonomic software price variation model that assigned a price to each of the plurality of discrete chunks, and a price update model that determines a number of downloads of each of the plurality of discrete chunks, wherein after a predetermined time period an updated price is computed for each of the plurality of discrete chunks. The present invention can also be viewed as a method that operates by dividing a software application into a plurality of discrete chunks, assigning a price to each of the plurality of discrete chunks, determining a number of downloads of each of the plurality of discrete chunks in a predetermined time period and computing an updated price for each of the plurality of discrete chunks. | 03-05-2009 |
20090064090 | MERGED VIEW OF APPLICATION CUSTOMIZATIONS - The customization system receives an application model that contains one or more elements stored in a database. The customization system receives a modification to an element of the application model. The customization system stores the modification to the element separately from the application model such that the application model is accessible in either a modified or unmodified state. Thus, multiple third parties can make changes to the same application model elements and business logic without causing conflicts with each other. In addition, updates and patches to the enterprise resource planning system can be applied with less likelihood that the customizations will be negatively affected. | 03-05-2009 |
20090064091 | CODE TRANSFORMATION - The invention concerns the transformation of executable code from one language to another. In particular, the invention concerns the automated transformation of code. The invention concerns methods, software and computer systems for the creation of a tree comprised of nodes to be used in the transformation of code. The invention also concerns the methods, software and computer systems for the building of a parser to be used in the transformation of code. Finally, the invention also concerns an automated and iterative method of transforming, assessing and re-transforming code. The invention is advantageous in its ability to avoid usage of an intermediate transformation language, and its high level of automation that reduces manual transformation and accordingly is more efficient and less costly. | 03-05-2009 |
20090070735 | METHOD AND APPARATUS FOR PROVIDING IMPLICIT VARIABILITY RULES FOR COMPONENT MODEL AND ARCHITECTURE DESIGN - A method and apparatus for providing variability rules for component model and architecture design are provided. The apparatus includes a category-determination unit which determines a category of implicit variability rules with respect to variability-set component model elements and elements associated with the variability-set component model elements; and an implicit-variability-rule-application unit which applies the implicit variability rules, which are given to the category, to the elements associated with the variability-set component model elements. | 03-12-2009 |
20090083695 | Enterprise Threat Analysis and Modeling - Systems and methods relating to a method for generating a threat analysis and modeling tool are described. In an implementation, aggregate analysis is performed upon applications of an enterprise for complete risk management of the enterprise. The threat analysis model is generated by defining the application, its attributes and the rules related to the application. An application task list is generated from a common task list for the application. Countermeasures for known attacks pertaining to the application are described in the application task list, which allows the developer to reduce the risk of attacks. | 03-26-2009 |
20090083696 | APPARATUS, AND ASSOCIATED METHODOLOGY, FOR PLANNING, MODELING, AND MONITORING A DEVELOPMENT PROCESS - A tool and an associated methodology for planning, modeling, and monitoring a development project are provided. The tool includes a centrally-positioned data base, such as at an SQL Server. An optimized model of the development project is created, and updates are provided thereto, such as updates provided by project personnel working at remote sites. Due to the centralization of the data and quantitative mechanisms by which to report to, and update the contents of, the data base, an accurate plan and model of the development project is made, facilitating improved tracking of the progress of the development project. | 03-26-2009 |
20090089738 | SOFTWARE CUSTOMIZATION SYSTEM AND METHOD - A system and method for the mass customization of software includes a software production line infrastructure, development environment, and actuator. The infrastructure organizes the software production line using a feature declarations component, a product definitions component, an automatons component, and a partition composition component. The development environment browses, displays, organizes, edits, and maintains the infrastructure. The actuator actuates the software production line to produce custom software products. | 04-02-2009 |
20090094575 | System and Method For Applying Model-Based Testing To Train Control Systems - A method for model-based testing of an industrial system includes modeling functionality of an industrial system using a modeling computer language, enhancing the model by adding functionality or refining existing functionality, generating test suites from the system model, and executing the test suites. The modeling computer language is the Unified Modeling Language (UML), wherein modeling includes defining UML use case diagrams to describe relationships among use cases specified for the system and actors who interact with the system according to the use cases, defining UML activity diagrams to model process logic of each use case, wherein the activity diagrams comprise a sequence of activities and transitions, and defining UML class diagrams to specify data categories and attributes that are inputs to the activities of the activity diagrams, wherein data categories relevant for a use case are modeled as test variables in the activity diagram. | 04-09-2009 |
20090094576 | Pattern-Based Development of Computer System Solutions - The problems that normally attend the development and deployment of a computer system solution are reduced by employing patterns and virtual images in the development and deployment process. When information had been acquired about a data processing need to be met, pattern representing a generalized solution to that need is selected. A set of previously-developed virtual images supporting the selected pattern is chosen. Once information representing the specific need is received, the selected pattern is modified to represent a specific solution. Parameters are obtained for the specific solution and a set of scripts integrating the parameters is generated. The scripts are used to reconfigure the virtual images. The reconfigured virtual images are combined into a computer system solution that can be loaded and run with little or no further configuration. | 04-09-2009 |
20090100405 | SYNCHRONIZING AN ABSTRACT MODEL AND SOURCE CODE - A software synchronization system detects a change that modifies an element of the abstract model. The software synchronization system globally modifies references to the element throughout the abstract model. Then the software synchronization system automatically determines elements of the source code that are dependent on the changed model element. The software synchronization system modifies the determined elements of the source code. Thus, the software synchronization system synchronizes the abstract model and the source code, regardless of the one to which the developer makes changes. | 04-16-2009 |
20090100406 | Software factory specification and execution model - A system that facilitates software development by providing a software factory based on an instance of a metamodel. The metamodel supports the definition of one or more viewpoints with a viewpoint comprising one or more work product types, templates for one or more tasks supporting the creation and modification of instances of the viewpoints and work product types, and templates for workstreams comprising one or more tasks and relationships between them. The metamodel supports definition of relationship(s) among viewpoints and/or between viewpoint(s) and work product type(s), and operation(s) that can be performed across relationship(s). Additionally, asset(s), if any, available to particular task(s) can further be defined as supported by the metamodel. | 04-16-2009 |
20090106732 | HIERARCHICAL DATA MODELS AND METHODS FOR NAVIGATING SAME - A method of programming a navigation system for a hierarchical data model includes coupling a processor in electronic data communication with an output device. The method also includes programming a hierarchical data model of a database within the processor. The hierarchical data model has a hierarchy representing a plurality of objects. At least one object of the plurality of objects has at least one attribute. The method further includes programming an entry point to at least a portion of the hierarchical data model within the processor. The entry point is programmed to generate an information list including each object of the plurality of objects having at least one common attribute. The information list is readable on the output device. | 04-23-2009 |
20090106733 | Software Engineering System and method for Self-Adaptive Dynamic Software Components - There is disclosed a software engineering system and method for engineering software components. In an embodiment, the method comprises providing the software component with an input interface, an output interface, and a control interface, the control interface being configurable to receive external conditions or parameters that are specific to an environment or to a domain; and providing one or more externally modifiable adapters, the one or more externally modifiable adapters having environment-specific or domain-specific data, and being configurable to be dynamically bound to the software component in dependence upon external conditions or parameters that are specific to an environment or to a domain in which the software component is to be executed. | 04-23-2009 |
20090106734 | BAYESIAN BELIEF NETWORK QUERY TOOL - A dataset query tool is disclosed, the query tool including a dataset having a plurality of attributes, wherein each of the attributes has one of a plurality of potential values, a processor adapted to develop a model of the dataset and calculate a posterior probability of at least one of the attributes of the dataset, wherein the model represents an approximation of the joint probability distribution of the dataset, a user interface in communication with the processor, wherein the user interface provides a means for a user to selectively identify values for at least one of the attributes of the dataset and selectively query at least one of the other attributes for a posterior probability calculation based on the identified values. | 04-23-2009 |
20090113379 | MODELING AND MANAGING HETEROGENEOUS APPLICATIONS - The present invention extends to methods, systems, and computer program products for modeling and managing heterogeneous applications. Application intent can be described in a relatively straight forward manner that abstracts underlying implementation details. Thus, application developers can develop applications without necessarily having to know extensive details of an underlying implementation environment. In any event, an application can be executed in different implementation environments without requiring changes to the corresponding model. | 04-30-2009 |
20090113380 | Integrated Model Checking and Issue Resolution Framework - A plurality of constraints are identified for a model of a software deployment in an integrated development environment. Each of the constraints are associated with one of a plurality of analysis levels. It is determined for each analysis level whether the corresponding associated constraints are met so that an identification indicating the same may be provided. Related techniques, apparatus, systems, and articles are described. | 04-30-2009 |
20090113381 | AGGREGATION OF CONSTRAINTS ACROSS PROFILES - Leveraging profiles to define stereotypes for other profiles introduces efficiency into modeling. Although constraints can be inherited, constraints cannot currently be aggregated across profiles. Aggregating constraints across profiles leverages the labor invested in defining other profiles as well as adding flexibility to defining stereotypes. | 04-30-2009 |
20090113382 | AUTOMATED DEPLOYMENT IMPLEMENTATION WITH A DEPLOYMENT TOPOLOGY MODEL - Although a modeling language can be used to create a deployment diagram to graphically depict a deployment model, the utility of the deployment diagram is limited to easing understanding of the model. A semantically correct deployment topology model can be processed to automate deployment of a product, add-on, update, configuration, etc. A semantically correct deployment topology model can be processed to generate activities that conform to the deployment model. The activities have executable code units associated with them. The executable code units are collected and organized to implement the deployment modeled with the deployment topology model. | 04-30-2009 |
20090138844 | Decorated Model Architecture for Efficient Model-Driven Application Development - A method for implementing a model-driven architecture, including defining a principal model having a plurality of classes, references, attributes, and associations between any of the classes, the model configured to facilitate the automatic generation of at least one resource for use by a computer-executable application, where a change to the principal model subsequent to performing the automatic generation requires the automatic generation be performed again in order to effect the change for use by the application, defining a decoration model having a class, reference, and attribute for any corresponding one of the primary model classes, references, and attributes, where a change to the decoration model subsequent to performing the automatic generation does not require the automatic generation be performed again in order to effect the change for use by the application, mapping the decoration model to the principal model, and storing both of the models on a computer-readable medium. | 05-28-2009 |
20090150854 | Computer Method and Apparatus for Providing Model to Model Transformation Using an MDA Approach - A Model Transformation Authoring Framework (MTAF)method and apparatus for authoring and providing model-to-model transformations from one domain to another domain is disclosed. Given a domain and a target domain, at least the given domain having a respective structured hierarchy, the invention system enables a user to specify a declarative mapping (transformation declarative) between a domain specific language modeling the given domain and a modeling language modeling the target domain. The declarative mapping models how the domain specific language modeling the given domain relates to the modeling language of the target domain. The system generates a transformation code implementation of a transformation from the given domain to the target domain. The MTAF provides to the user design decisions with respect to Specification, Transformation Rules, Rule Organization, Rule Application Control, Source-Target Relationship, Incrementality, and Directionality and Tracing. The generated transformation code is executed at runtime to perform the transformation of the domain specific language of the given domain to the modeling language of the target domain. Instances of models of the target domain resulting from the performed transformation at runtime may be output to other model transformations, to JET templates, or may be persisted, merged or chained among other post processing. | 06-11-2009 |
20090150855 | Computer Method and Apparatus for Model Transformation Reapply - Provided is a method and system for model transformation reapply. Through a programming model transformation, a target model is generated. The target model has one or more model elements. As manual changes are made to the target model, parts of the target model are marked as non-changeable by annotations. The annotations are inserted into respective model elements of the target model and indicate which parts are non-changeable and thus preservable. The annotations enable reapplying of the transformation to make changes to the target model but preserve manual changes made to the model elements based on the inserted annotations. The reapply of the transformation may be configured with options to handle the deltas between the existing target model and newly generated target models of the transformation. | 06-11-2009 |
20090150856 | UML Profile Transformation Authoring Method and System - A method and apparatus for authoring model-to-model transformations of programming models involving profiles is disclosed. Using a declarative mapping between a given profile of a subject programming model and a target profile of a target programming model, transformation of the given profile is specified and results in a declarative specification. Similarly the declarative mapping may be to a profile of a target programming model (without a corresponding source side profile) or from a profile of a source programming model (without a corresponding target side profile). Based on the declarative specification, a transformation code implementation (e.g. a transformation API) is generated. The given profile is specified as an input domain or as an output domain along with a meta model of the subject programming model. The generated transformation code implementation effectively handles complexities of dealing with the given profile at run time. | 06-11-2009 |
20090150857 | PERFORMANCE SOFTWARE INSTRUMENTATION AND ANALYSIS FOR ELECTRONIC DESIGN AUTOMATION - Various methods and apparatuses are described that provide instrumentation and analysis of an electronic design. A method for providing performance instrumentation and analysis of the electronic design includes defining a first and second set of intended software instrumentation test points and an associated first and second set of performance analysis units. The method further includes instrumenting the first and second sets of software instrumentation test points and the associated first and second sets of performance analysis units to a first model and a second model, respectively. The method further includes creating a first and a second set of software instances associated with the first and second sets of intended software instrumentation test points and associated sets of performance analysis units during run time of a first simulation and a second simulation of the electronic design associated with the first model and second model, respectively. | 06-11-2009 |
20090150858 | Extensible context based user interface simplification - Embodiments of the present invention address deficiencies of the art in respect to modeling tools and provide a method, system and computer program product for extensible context based user interface simplification of modeling components for a modeling tool. In an embodiment of the invention, a method for extensible context based user interface simplification can be provided for a model driven development tool. The method can include detecting a context change to a new context in a model driven development tool, locating tool items mapped to the new context, and displaying the located tool items in the model driven development tool. | 06-11-2009 |
20090150859 | Dynamic validation of models using constraint targets - Embodiments of the present invention address deficiencies of the art in respect to model validation for modeling tools and provide a novel and non-obvious method, system and computer program product for dynamic validation of models using constraint targets. In an embodiment of the invention, a method for dynamic validation of models using constraint targets can be provided. The method can include defining constraint targets on object validation in a model within a MDD tool to object instances affected by a change in another object in the model, detecting a change in an object instance in the model in the MDD tool, and validating only other object instances in the model that are affected by the detected change. | 06-11-2009 |
20090150860 | METHOD AND SYSTEM FOR COMBINING QUALITY ASSURANCE AND MODEL TRANSFORMATIONS IN A BUSINESS-DRIVEN DEVELOPMENT ENVIRONMENT - A system for combining quality assurance and model transformations in a business-driven development environment includes a host system executing a business modeling application, a transformation framework including a transformation programming interface (TPI) and a quality assurance framework executing on top of the business modeling application, and a plurality of transformation plug-in tools in communication with the TPI. The TPI includes options for model access and traversal, model element creation/removal, model element property editing and analysis. The options are applied to the transformations, via the selected transformation plug-in tools, to a business model resulting in a modified business model that conforms to an information technology (IT)-based executable code. The quality assurance framework performs single-entry-single-exit (SESE) fragment decomposition of the modified business model, control-flow analysis, and notification to the user of any detected error conditions, the notification presented to the user with the modified business model via the TPI. | 06-11-2009 |
20090158240 | METHOD AND APPARATUS FOR MODELING AND MANAGING QUALITY OF SERVICE (QOS) IN A SERVICE-ORIENTED ARCHITECTURE (SOA) ENVIRONMENT - A method is provided for implementing data-driven QoS control in design and development of an SOA solution. The method comprises implementing a QoS layer having a first set of architectural building blocks (ABBs) and configured to specify a QoS requirement definition to be propagated through a set of components of the SOA solution to generate QoS data for controlling and managing QoS in a unified form; and implementing a data architecture layer having a second set of ABBs and configured to facilitate propagation of generated QoS data through the set of components in the SOA solution. | 06-18-2009 |
20090158241 | GENERATING A MANAGEMENT PACK AT PROGRAM BUILD TIME - Technologies are described herein for generating a management pack at program build time. Data is received that defines one or more events generated by the application program. Data is also received that defines one or more management classes for the application program. When a request to build the program is received, the data defining the events generated by the program and the data defining the management classes is utilized to generate a management pack for the program in an automated fashion. Once the management pack has been generated, it may be provided to an operations manager application program for use in monitoring the operation of the application program. | 06-18-2009 |
20090158242 | LIBRARY OF SERVICES TO GUARANTEE TRANSACTION PROCESSING APPLICATION IS FULLY TRANSACTIONAL - A transaction processing development methodology employs a transaction processing development framework to facilitate development of a desired transaction processing application in a particular business area. A library of service adaptors is provided. At least a first portion of the service adaptors are generically applicable to transaction processing applications that are fully transactional and at least a second portion of the service adaptors are specifically applicable to transaction processing applications in a particular business area. A user-defined business logic of the desired transaction processing application is processed to instantiate the transaction processing application, including instantiating service adaptors from the first portion of the service adaptors and from the second portion of the service adaptors, to implement services of the transaction processing application. The instantiated service adaptors are arranged to guarantee such that, when executed, the transaction processing application is accomplished in a manner that is fully transactional. | 06-18-2009 |
20090172632 | Method, System, and Computer Program Product for Implementing External Domain Independent Modeling Framework in a System Design - Disclosed are a method, system, and computer program product for implementing external domain independent modeling framework in a system design. In some embodiments, the method or system comprises importing an external model in an external format into the framework while substantially preserving some or all of the interpretation of the external model, determining a internal common representation for the external model within the framework, and displaying or storing the internal common representation in a tangible computer readable medium. In some embodiments, the method or system further comprises validating the accuracy of the internal common representation, determining an analysis or transformation capability for the framework, or outputting a first output model in a second external format. In various embodiments, the method or system requires no external tool compliance. | 07-02-2009 |
20090172633 | METHODS OF TRANSFORMING APPLICATION LAYER STRUCTURE AS OBJECTS - Embodiments consistent with the invention transform business application logic entities or structures into OOP structures that represent the data, relationships, and operations of the business application structures. The business application structures are transformed from the application level, including consideration of the business application logic and relationships. In one embodiment, transformation is done using a set of automated transformation rules. The resulting OOP structure model of the business application structure may be used with OOP tools to analyze, maintain, debug, modify, and revise the business application structure, and to create new structures for the business application. | 07-02-2009 |
20090178019 | System and Method for Multi-Level Security Filtering of Model Representations - A system and method for multi-level security filtering of model representations. Elements of an architecture and systems engineering model have associated security characteristics identifying the required level of security that a user must have in order to be able to obtain access to information about that element of the model. Based on these security characteristics and the security level of a user attempting to access the model, the content of the model is modified such that elements that are not accessible by a user having that security level are obscured or not visible to the user. The other elements of the model which are accessible by the user based on his/her security level are modified in the modified model so as to not provide information that would disclose the nature, character, or in some cases even the presence, of the elements that are not accessible by the user based on his/her security level. | 07-09-2009 |
20090178020 | CREATING CUSTOMIZED APPLICATIONS USING TEMPLATES HAVING POINTS OF VARIABILITY - A method, system, apparatus and article of manufacture for producing a customized application. In a preferred method of the invention, a selection of components can be identified which are to be deployed to form the customized application. Within the selection of components, points of variability can be specified which can be assigned values when deploying the selection of components. The identified selection of components and the specified points of variability can be persisted in a template. Subsequently, the template can be processed to deploy the identified selection of components, to prompt for values to be assigned to the points of variability, and to configure the identified selection of components with the values at the points of variability thereby producing the customized application. | 07-09-2009 |
20090178021 | Systems and Methods for Modeling and Generating Test Requirements for Software Applications - Systems, methods, and computer-readable storage media are described for modeling the requirements of software to generate test requirements. In one exemplary embodiment, a computer-implemented method comprises generating a model of the requirements using a tree graph model, identifying primary paths of the tree graph model using an algorithm, and creating test cases based on the identified primary paths. | 07-09-2009 |
20090187881 | DIFFERENCE LOG PRODUCTION FOR MODEL MERGING - Methods and apparatus are provided for production of a difference log in a data processing system The difference log defines differences between process models defined in system memory. For each of the process models, model structure data provided in memory defines a hierarchy of SESE regions representing the structure of that model. Also provided in memory are model comparison data defining correspondences between elements of the models, and region comparison data defining correspondences between regions of the SESE region hierarchies for the models. The model comparison and region comparison data are analyzed to identify differences between the SESE region hierarchies, and a difference log defining said differences is produced. In preferred systems, the model structure data and the region comparison data is computed for the models, and the difference log has a hierarchical structure corresponding to the structure of the process models. | 07-23-2009 |
20090193389 | REALTIME CREATION OF DATASETS IN MODEL BASED TESTING - Some embodiments of the present invention provide a system that tests a software program. During operation, the system creates a behavioral model of the software program using branches, decisions, and options. Next, the system applies a weight assignment technique to the behavioral model to create a set of global identifiers (IDs), which correspond to test cases of the behavioral model. The system then generates a test case from the behavioral model and executes the test case on the software program. Finally, the system analyzes an output of the executed test case to determine a validity of the software program. | 07-30-2009 |
20090193390 | TECHNIQUES FOR MODELING VARIABLES IN SUBPROGRAMS OF HARDWARE DESCRIPTION LANGUAGE PROGRAMS - A method, system and computer program product for modeling variables in subprograms of a HDL program. A subprogram is provided with an initial value of a variable of an element being modeled and the subprogram is stored in memory of a data processing system. In response to a subprogram call, a copy of the stored subprogram is provided to the requesting HDL program. During execution, the initial value of the variable in the provided copy of the subprogram may be modified by the HDL program, but the value retains unchanged in the stored subprogram. | 07-30-2009 |
20090199156 | CONSTRAINT LANGUAGE EDITING FOR GENERATING MODEL-RELATED CONSTRAINT EXPRESSIONS - A method and navigation helper for generating constraint language codes for navigation in a constraint language editor. The constraint language editor generates model/instance-related constraint expressions according to the loaded model/instance and related constraints. The navigation is a path implementing the constraints. The method includes parsing the loaded model/instance; calculating a possible association related to the element through the type of the navigation-related element in the model/instance; and calculating a possible navigation path according to the association. A method for generating constraint language codes in a constraint language editor and the constraint language editor includes loading the model/instance; loading constraint patterns for storing parameters and a constraint code template; invoking corresponding helpers, according to the types of parameters stored in the constraint patterns; and generating constraint codes according to the generated parameters and the constraint code template. | 08-06-2009 |
20090204937 | Conversion of a First Executable Diagram Having Interconnected Nodes to a Second Executable Diagram Using an Intermediate XML Representation - A system and method for programmatically generating a graphical program in response to state diagram information. The state diagram information may specify a plurality of states and state transitions, wherein each state transition specifies a transition from a first state to a second state. A graphical program generation program (GPG program), may receive the state diagram information and automatically, i.e., programmatically, generate a graphical program (or graphical program portion) based on the state diagram information. The GPG program may programmatically include graphical source code in a block diagram of the graphical program, which may serve as a framework of the states specified by the state diagram information and the state transitions among the states. The graphical source code framework automatically generated by the GPG program may include various “placeholders” or “containers” enabling the user to easily fill in the graphical program with source code that specifies execution instructions for each state and Boolean conditions for each state transition. The specific graphical source code that is automatically generated may depend on programming features supported by a particular graphical programming development environment with which the graphical program is associated. Examples of generating graphical source code for the LabVIEW graphical programming development environment are included. In one embodiment, the graphical program may be dynamically (programmatically) updated as the state diagram is being interactively constructed by the user. I.e., as the user performs various actions in a state diagram editor, such as adding or deleting states, adding or deleting transitions, etc., the corresponding graphical program may be dynamically (programmatically) updated to reflect the change. | 08-13-2009 |
20090217235 | Apparatus and Method of Generating Self-Debugging Computer Software - In one embodiment the present invention includes a computer-implemented method of self debugging a computer program operating in a distributed processing environment. The method includes detecting a fault in a plurality of processing devices and classifying the fault according to fault classifications. The fault classifications have corresponding responses. The method further includes executing one of the responses in accordance with the fault having been classified. The method further includes revising the computer program according to the response. This method may be embodied in a computer program or executed by a computer system. In this manner, the computer program performs self debugging. | 08-27-2009 |
20090222789 | Compiler for a Declarative Event-Driven Programming Model - A compiler generates code providing an execution sequence, from a declarative event-driven model, for execution by a computer. To assist in debugging the declarative event-driven model, the compiler also generates cross-references that relate steps in the generated code to elements of the declarative source code. The cross-references may be used as input to a debugger, along with the declarative source and the generated code, to assist a user who is stepping through the generated code (for example) in understanding which portion of the declarative source gave rise to the current step in the generated execution sequence. | 09-03-2009 |
20090222790 | SYSTEM AND METHOD FOR PROCESSING RESOURCE DESCRIPTION FRAMEWORK DATA - The present invention relates to a system and method for processing resource description framework data. The present invention relates to a system and method allowing a general-purpose program to support operation of resource description language (RDF) data models, not operation of RDF ontology using a library. Therefore, it is possible to process RDF data by using an existing high-level programming language. Further, since a developer clearly perceives RDF data models, it is possible to easily operate RDF ontology. | 09-03-2009 |
20090235226 | Synthesis of Message Sequence Charts from Communicating Finite-State Machines - Synthesizing a message sequence chart (MSC) from a communicating finite-state machine (CFSM), by transforming the CFSM to a Petri net model, generating a labeled finite digraph with each path representing a linearization of an occurrence net segment of the Petri net, decomposing the diagraph into segments, and mapping where each segment to a compositional MSC. | 09-17-2009 |
20090235227 | Variability Layer for Domain-Specific Modeling Languages - Methods and systems are provided for adding variability support for a modeling language. Developers may utilize the added support to transform a model written in a preexisting domain-specific modeling language for product line development in which there is structural and configurational diversity. A variability layer is incorporated into the model, which permits product developers to better use the language to model product line variants. | 09-17-2009 |
20090249281 | PERFORMANCE-RELATED DECISION SUPPORT FOR MODEL-DRIVEN ENGINEERING - A performance analysis model may be determined based on a development model associated with development of a software process, the development model defining an execution of the software process, and the performance analysis model being annotated with performance data characterizing the execution. At least one user-specified performance profile characterizing performance parameters associated with an improved execution of the software process according to the development model may be determined. An assessment computation model may be determined, using the performance analysis model and the at least one user-specified performance profile. At least one performance-based characteristic associated with the improved execution of the software process according to the development model may be determined. A performance assessment model may be determined using the assessment computation model and the performance-based characteristic, for use in modifying the development model based on the performance assessment model to obtain the improved execution of the software process. | 10-01-2009 |
20090249282 | CROSS PLATFORM COMPOSITIONAL WIDGETS - Mechanisms are afforded for supporting cross platform widgets. A generic widget can be converted into a specialized widget of a corresponding platform. Dually, a specialized widget can be generalized to a generic widget for subsequent deployment on the same or different host. Furthermore, support is provided for compositional widgets across platforms. | 10-01-2009 |
20090249283 | Modelling software appliance - The present invention relates to a method of creation of a software appliance remarkable in that it comprises at least the step of modelling the software appliance. Said step of modelling comprises the step of defining the following set of categories:
| 10-01-2009 |
20090249284 | AUTOMATION FOR VIRTUALIZED IT ENVIRONMENTS - A system automatically builds custom virtual appliances and/or other computing environments and their components, where applicable, based on user requirements and may offer a service for hosting, maintaining, monitoring and managing such appliances remotely. These virtual appliances may be delivered over a network, such as the Internet, and can be run at a customer site or at a hosting provider. Some embodiments of the invention can build these appliances using custom applications developed by customers. | 10-01-2009 |
20090259986 | Class selectable design sharing - In one illustrative embodiment, there is a computer implemented method for class selectable design sharing. The computer implemented method comprises, obtaining a set of classes for a design model from a source system, and identifying desired classes from the set of classes to form an identified subset of classes. The computer implemented method further exporting the identified subset of classes from the design model of the source system to a design model of a target system. | 10-15-2009 |
20090265682 | METHOD FOR TRANSFORMING DATA FROM A MODEL INTO A SECONDARY MODEL TO OPTIMIZE CODE GENERATION - A method for generating code includes receiving an eclipse modeling framework (EMF) model representing data in a structure from a source code application, parsing data from an EMF model, transforming parsed data into a secondary model, the secondary model being configured for a destination data structure, and generating code through java emitter templates (JET) based upon the secondary model. | 10-22-2009 |
20090265683 | METHODS AND SYSTEMS FOR SUPPORTING MULTIPLE DEPLOYMENT MODELS OF ENTERPRISE BUSINESS APPLICATIONS - This disclosure describes, generally, methods and systems for supporting multiple deployment models for enterprise business applications. In one embodiment, the method may include designating pillars associated with an enterprise business application. Each pillar may include application units which comprise logical groupings for application units used in the enterprise business application. The method may further include determining which of the application units are dependent to more than one of the pillars. Furthermore, based on the determination of the dependent application units, the method may generate deployment code associated with the dependent application units which is configured to be deployment model independent. The method may then receive, at deployment time, a deployment model designation indicating a type of deployment model selected to be used for the enterprise business application. Then, the enterprise business application may be deployed according to the deployment model designation. | 10-22-2009 |
20090282384 | Framework-Based Model-Driven Software Development - In accordance with certain embodiments of the present invention, a method includes generating a platform independent software framework using a graphical modeling language. The platform independent software framework includes one or more platform independent components each describing a platform independent behavior common to each of a plurality of computing platforms and one or more platform specific components each corresponding to a platform specific plug-ins of a platform specific model. The platform specific model corresponds to one of the plurality of computing platforms. The method further includes generating, using the graphical modeling language, a particular platform specific model corresponding to a particular computing platform of the one or more computing platforms. The particular platform model includes one or more platform specific plug-ins each corresponding to a platform specific component of the platform independent framework and describing a platform specific behavior for the particular computing platform. | 11-12-2009 |
20090300578 | System and Method For Developing An Application For Extending Access to Local Software Of A Wireless Device - A system and method for developing an application for subsequent deployment on a mobile device, the mobile device configured for using the deployed application to communicate over a network with a data source through a transaction server. The system and method comprising: an interface component module for providing access to a defined interface component for use in providing communication between the application and a local software configured to be resident on the mobile device; and a composer module for defining a text file containing definitions expressed in a structured definition language, the definitions describing a message section and a data section and a user interface section of the application, the composer module further for inserting handler definitions in the text file such that the handler definitions are configured for calling the interface component of the interface component module. | 12-03-2009 |
20090307652 | AUTOMATIC MODEL-SPECIFIC DEBUGGER EXTENSIONS - Extensions to a debugger are identified in a debugger database which is read automatically when the debugger loads. The debugger watches for trigger events in its execution environment and optionally for load conditions in a debuggee program's internal state. If a trigger event occurs and a load condition is met, then the debugger automatically loads an extension for use. Some extensions provide debugging routines that are specifically designed to support debugging of applications which use a specific programming model. | 12-10-2009 |
20090319981 | SYSTEM AND METHOD FOR GENERATING IMPLEMENTATION ARTIFACTS FOR CONTEXTUALLY-AWARE BUSINESS APPLICATIONS - A method for generating implementation artifacts for contextually-aware business applications includes utilizing a platform independent model (PIM) of a business application; generating a platform specific model (PSM) from the PIM, wherein the generating of a PSM includes one or more transformations between one or more meta-models of the PIM and one or more meta-models of the generated PSM; generating implementation artifacts; and binding the generated implementation artifacts with any existing services of the business application. | 12-24-2009 |
20090319982 | Multiple Code Inheritance with Explicit Base Calling - Embodiments described herein are directed to extending a software interface to include non-public functions. In one embodiment, a computer system receives a user input indicating that an interface is to be used to manage code inheritance in the generation of a software application. The interface includes a public functions declaration identifying functions that are publicly available to generate an application. The computer system determines that the received indication indicates that a non-public function is to be used in addition to any public functions, where the non-public function is accessible through the interface. The computer system also generates a software application using the non-public function and a public function, as indicated in the received user input. | 12-24-2009 |
20090319983 | Intellectual property model creating apparatus, intellectual property model creating method, and computer product - A model managing apparatus manages an intellectual property model formed by using program description to model a function to be realized as hardware. The model managing apparatus includes a data storing unit that stores and manages therein electronic system levels that are components into which the intellectual property model is divided. The components are an application program interface that defines external communications, a register that defines data to be input and output, and a behavior that defines a function or a computation. The data storing unit further stores therein connection data that defines connection relations between the register and the behavior, between behaviors, and between the behavior and the application program interface. | 12-24-2009 |
20090327993 | Extension Model for Improved Parsing and Describing Protocols - Described is a technology by which an engine parses data based upon modules arranged in a tree-like model structure. Only those modules that meet a condition with respect to the data are invoked for processing the data. Each child module specifies a parent module and specifies a condition for when the parent is to invoke the child module. As a module processes the data, if a child module's specified condition is met, it invokes the corresponding child module, (which in turn may invoke a lower child if its condition is met, and so on). When the data corresponds to protocols, the model facilitates protocol layering. A top level parent may represent one protocol (e.g., TCP), a child beneath may represent a lower-layer protocol (e.g., HTTP), whose children may handle certain types of HTTP commands, or correspond to a signature that the child module is programmed to detect. | 12-31-2009 |
20100011337 | OPEN APPLICATION LIFECYCLE MANAGEMENT FRAMEWORK DOMAIN MODEL - Techniques for an open application lifecycle management framework domain model are described, including evaluating data retrieved from an application in data communication with a framework hosted by a computer, identifying an element associated with the data and another element associated with the framework, creating a common data representation associated with the element, wherein the common data representation is generated according to a domain model associated with the framework, and generating a map associating the common data representation to the element and another element associated with the framework. | 01-14-2010 |
20100023922 | LINKING UML ACTIVITY DIAGRAM NODES TO UML CLASS DIAGRAM NODES BY USING PROPERTIES FROM APPLIED STEREOTYPES - The present disclosure is directed to a method for associating an UML activity diagram with an UML class diagram. The method may comprise applying stereotypes to nodes in the UML activity diagram; specifying properties for the stereotypes, the properties may include information for linking nodes in activity diagram to role names in the class diagram; providing a mapping between nodes in the activity diagram and relationship objects in the class diagram based on the properties; and associating the activity diagram with the class diagram utilizing the mapping. | 01-28-2010 |
20100023923 | METHOD FOR MEDELING OBJECTS IN A HETROGENIOUS COMPUTING ENVIRONMENT - A meta language for developing object classes to be used in multi-platform systems, optionally using multiple environments and languages. The code of the object classes comprise structure and logic. The code is converted into native languages, for example by preprocessing mechanisms, and then compiled if necessary into programs executable by the computing platforms. | 01-28-2010 |
20100031228 | Process for testing models - A process for testing models to see whether or not these models satisfy the modeling standard. | 02-04-2010 |
20100037201 | Separation Of Concerns Between Information Technology Services Models - Methods, systems, and computer program products are provided for exchanging information between information technology (IT) services. An architecture provides separation of concern between the models by separating the models for IT services into an operation model and a structural model that are linked by a service model. The service model can be configurable to extend the operation model. Configuration of the operation model includes defining messages exchanged between the IT services. Configuration of the structural model includes capturing a structure of the IT services. The service model has an association with the structural model, the association making the structural model opaque to the operation model. | 02-11-2010 |
20100058285 | COMPOSITIONAL VIEW OF IMPERATIVE OBJECT MODEL - A compositional or alternate object model is employed over an imperative object model to facilitate inspection and construction of imperative structures in a user-friendly manner. Transformations between compositional and imperative models and vice versa can be specified to provide a bridge between differing computing worlds. Moreover, various architectures and/or design patterns can be employed to effect transformation in different ways. | 03-04-2010 |
20100058286 | SYSTEM AND A METHOD FOR RENDERING COMPUTER-BASED INTERACTIONS AS GROUP ACTIVITIES - Disclosed herein is a system and a method for creating and facilitating computer-based interactions amongst a group of individuals during a group activity. In an embodiment herein, an activity player is provided for rendering instances of the group activity. A library of activity templates is also provided so that instances of said activity templates may be used to create an activity executable. An activity data file may be created for storing data corresponding to the instances of activity templates used in the activity executable, wherein said activity executable and activity data file are used to create the group activity. Said group activity may be then rendered by the activity player. | 03-04-2010 |
20100058287 | MODEL DRIVEN SOFTWARE - A system and method for model driven software is disclosed. In one embodiment, the method of handling changes to a software system in a business environment includes capturing customer requirements of the software system in a schema, modeling business-software architecture of the software system in a first level of the schema, modeling design architecture of the software system in a second level of the schema, defining events that connect the first level and second level of the schema, defining links that represent interactions between the user interfaces, defining integration services for each of the events, mapping each element in the first level to a corresponding one of elements in the second level using the events, links and integration services, creating a knowledge repository with a traversable user interface representing the mappings, identifying changes to the software system, and analyzing impact of the changes using the knowledge repository. | 03-04-2010 |
20100064275 | EXTRACTING PLATFORM INDEPENDENT MODELS FROM COMPOSITE APPLICATIONS - A system and method for extracting a platform independent model (PIM) from the existing implementation artifacts of a composite application via an intermediary platform specific model (PSM) using model-driven transformations. Meta-models for the PSM and PIM are prepared and mapping rules are specified therebetween. The mapping rules can be created manually or derived automatically via ontology mapping techniques. Once specified, model driven transformations that codify the mapping rules generate the PIM which may include the structural, behavioral and user experience models of the composite application. To enhance the reusability of the extracted PIM, a business level service model along with a service dependency model is generated rather than IT level classes. These higher levels of abstraction enable the models to be linked with business objectives, which is important for companies to understand and maintain their service portfolios. | 03-11-2010 |
20100077376 | Creating an executable configuration - The automatization unit used in current test stands is a central system in which various interfaces are connected with the individual test stand components. As a result, an inflexible system is created with limited scalability, as numerous changes are required in the automatization unit, for example, a new interface, processing of data from/to the component, integration into the existing system, etc. in order to integrate new components (SW and HW). This makes a change or an enhancement of the automatization unit, the implementation of specific customer requests or the integration of an external functionality very expensive. In order to solve this problem and primarily, to make a flexible easily scalable system possible it is proposed in accordance with the invention, to create an executable configuration that can be run on a target system by selecting from a library | 03-25-2010 |
20100083212 | NON-INTRUSIVE MODEL ANNOTATION - Development models of software applications may be annotated with additional information and transformed within a transformation chain into a resulting model that may be used to evaluate the development model, for example, for simulation and/or performance support of the development model. By relating elements of the development model through the transformation chain to elements of the resulting model, the evaluation may be performed with respect to the resulting/transformed model, but provided to a user in terms of the original development model. In this way, a user of the development model may work with the more-familiar development model, without having to alter the development model directly in order to obtain the evaluation. | 04-01-2010 |
20100083213 | APPLICATION BUILDER FOR INDUSTRIAL AUTOMATION - A control system development platform is provided. The platform includes a shell component adapted to support development of a control systems application. An abstract model is associated with the shell component to facilitate development of the control systems applications. | 04-01-2010 |
20100083214 | DESIGN DESCRIPTION REWRITING DEVICE, DESIGN DESCRIPTION REWRITING METHOD, AND COMPUTER READABLE MEDIUM - There is provided with a device that includes a first inputter inputting design description which includes functions; a second inputter inputting type specifying description corresponding to the functions, each of which specifies a type for a return value of each corresponding function, and the description of at least one function of the functions specifies a type for a return value of a first function which is an other function of functions; a determiner determining a type of the return value of the first function to a comprehensive type to comprehend the types specified by the type specifying description corresponding to the first function and the at least one function and a type of the return value of a second function which is a function than the first function to the type specified thereto. | 04-01-2010 |
20100088665 | TREE-BASED DIRECTED GRAPH PROGRAMMING STRUCTURES FOR A DECLARATIVE PROGRAMMING LANGUAGE - Embodiments of tree-based directed graph programming structures for a declarative programming language are provided. In various embodiments, complex graph structured data, referred to as “DGraphs” herein in one non-limiting implementation, is authored using a compact, human friendly syntax without the use of explicit identifiers. In one non-limiting aspect, the syntax includes support for conformance relationships, also referred to as factored relationships. In another non-limiting aspect, the semistructured graph data is a tree-based representation and the syntax includes lexical resolution of references or lexical scoping, and/or non local initialization. | 04-08-2010 |
20100088666 | COMMON INTERMEDIATE REPRESENTATION FOR DATA SCRIPTING LANGUAGE - A common intermediate representation for a data scripting language is provided for efficient representation and direct specification of programming constructs in memory. The common intermediate representation of data scripts allows data intensive applications to be created and analyzed in a machine accessible format, and the elements of the common intermediate representation can be stored independent of underlying storage specifics. Stored elements of the common intermediate representation of code are thus available for fast loading in memory when desired by other applications and programs by mapping the stored elements to the in memory intermediate representation. | 04-08-2010 |
20100088667 | METHOD AND SYSTEM TO MODELIZE RESOURCES AND EXTERNAL DATA OF A PROGRAM FOR PROCEDURAL LANGUAGE CODING - A method and system to represent in UML the resources and external data manipulated by a program to be coded in a procedural language is disclosed. The usual UML class diagram is enhanced with two new stereotypes “Program” and “Data Object”. The program stereotypes applied to an operation and its parameters describe the data manipulated, through the logical definition provided by the Data Object. This model will be enhanced in order to introduce classes on which the Resource stereotype is applied. These classes will be connected to the appropriate logical data definition (the Data Object) and used as parameter types of the operation instead of the Data Object. A second set of stereotypes will be applied to the Resource classes to indicate the physical type of the resource (a file, table etc. . . . ) and its characteristics. Parameters that point to a DataObject or a primitive type will be considered as external data. | 04-08-2010 |
20100095269 | FACETED, TAG-BASED APPROACH FOR THE DESIGN AND COMPOSITION OF COMPONENTS AND APPLICATIONS IN COMPONENT-BASED SYSTEMS - A method, including: receiving a software requirement; and constructing a workflow template that can satisfy the software requirement, wherein the workflow template comprises a plurality of processing stages, wherein each processing stage includes at least one component class and each component class includes at least one component, and wherein an output of each processing stage is described by a processing goal pattern that is described by a set of tags and facets. | 04-15-2010 |
20100107135 | System and Method for Transforming a Component Business Model - Seamless transition from a Component Business Model (CBM) to a Services Oriented Architecture (SOA) is achieved by converting a tabular representation of a CBM Heat Map to a Unified Modeling Language (UML) representation, and automatically converting the UML representation of a CBM Heat Map to a first iteration of input used during the subsequent SOA solution development using Service Oriented Modeling and Architecture (SOMA). | 04-29-2010 |
20100115490 | Automated Lifecycle Management of a Computer Implemented Service - A system for automated lifecycle management of a computer implemented service, according to requirements, having a service model ( | 05-06-2010 |
20100115491 | METHOD AND APPARATUS FOR DEVELOPING A SOFTWARE APPLICATION - A method and apparatus for developing a computer program utilizing services that may not be available during development. A dummy service providing a naïve implementation of the service that is to be provided by the services is obtained or created. The computer program is modified such that it utilizes the dummy service. After an actual service is available, the computer program is modified once more to utilize the actual service instead of the dummy service. | 05-06-2010 |
20100125824 | Method and apparatus for supporting application enhancement - A method includes generating an application model that represents a relation of connection based on a control flow relation and a data dependency relation between a module and data constituting an application, by analyzing a source code, evaluating complexity of the relation of connection that is represented by the application model generated in the generating, and outputting an enhancement point used in reducing the complexity evaluated in the evaluating. | 05-20-2010 |
20100131916 | SOFTWARE FOR MODELING BUSINESS TASKS - This disclosure provides various embodiments of software for generating a business task model. In one aspect, the software identifies a triggering entity associated with a particular process component, and defines a task associated with the particular process component, where the task represents a runtime request to perform an activity. Further, the software defines at least one connection between the triggering entity and the defined task, the triggering entity at least determining when the defined task is created. The software is further operable to represent the connections between the triggering entity and the defined task in a business task model within a modeling environment. | 05-27-2010 |
20100131917 | APPARATUS AND METHOD FOR DESIGNING A SYSTEM SPECIFICATION FOR TESTABILITY - As to a plurality of components in a system, a state transition path covering transitions defined by a behavioral specification of a component is specified to satisfy an input restriction of the component. Action sequences are acquired from the state transition path. By selecting a pair of components connected in the system, it is verified whether an output action sequence of a first component as one of the pair satisfies an input restriction of a second component as the other of the pair. If unsatisfied, the input restriction of the second component is relaxed to satisfy the output action sequence of the first component, or an input restriction of the first component is tightened to acquire a new output action sequence satisfying the input restriction of the second component. Above processing is repeated for each pair of components, so that output action sequences of one and the other of a pair satisfies input restrictions of the other and the one of the pair respectively. | 05-27-2010 |
20100138808 | EMBEDDED SYSTEM DESIGN DEVICE AND A METHOD THEREOF USING A TARGET INDEPENDENT MODEL - The present invention provides an embedded system design device and a method thereof using a target independent model comprises: a target independent model expressed in UML diagram type as a resource; a target independent model definition language for expressing the target independent model in language type; a profile where specific data for substantially controlling a particular embedded system is stored; a middle language configured by inserting contents of the profile into the target independent model definition language; a conversion language configured in the same linguistic type as the middle language, and for adding new data which does not exist in the middle language, or for changing particular contents; a target dependent model definition language generated by applying the conversion language to the middle language; and a modeling tool for performing a series of processing procedures of writing a diagram by using a UML (Unified Modeling Language), providing an interface tag which suggests resource items for extracting/generating the target independent model, and generating the target independent model to convert the independent model into the target dependent model. | 06-03-2010 |
20100138809 | SYSTEM AND METHOD AND APPARATUS FOR USING UML TOOLS FOR DEFINING WEB SERVICE BOUND COMPONENT APPLICATIONS - An application development system for developing an application with application components is described. The system application development includes a modeling tool. The modeling tool imports the application components in a comparable component definition format, and defines a data relation between data, screens, and operations embodied in the application components in an application model. The application model has a static structural characteristic, a dynamic behavioral characteristic and an implementation characteristic. The static structural characteristic defines parts of the application. The dynamic behavioral characteristic defines responsiveness of the application to events or actions, and the implementation characteristic describes elements required for deploying the application. The modeling tool updates the cross-component mapping. The modeling tool further includes a mapping analyzer for analyzing message components and data components in the application components, and generating a cross-component mapping. | 06-03-2010 |
20100153906 | CAPTURING INFORMATION ACCESSED, UPDATED AND CREATED BY SERVICES AND USING THE SAME FOR VALIDATION OF CONSISTENCY - Techniques for extending a service model with specification of information consumed. The service model includes specification of at least one exposed interface. A receiving operation receives specification of information consumed by a service implementation of the service model. The information consumed is information that is or needs be utilized by the service implementation without being passed through the exposed interface. A generating operation automatically generates an extended service model using a computer processor. The extended service model includes specification of the exposed interface and specification of the information consumed by the service implementation. | 06-17-2010 |
20100153907 | Configurable Unified Modeling Language Building Blocks - Illustrative embodiments provide a computer-implemented method for configurable Unified Modeling Language building blocks. The computer-implemented method obtains a Unified Modeling Language specification and generates a set of logical units from the Unified Modeling Language specification to form a set of building blocks. The computer-implemented method further fetches desired blocks from the set of building blocks according to predefined criteria to form a set of desired blocks, and presents the set of desired building blocks to a requestor for execution of functions provided by the set of desired building blocks to complete a defined task. | 06-17-2010 |
20100153908 | IMPACT ANALYSIS OF SOFTWARE CHANGE REQUESTS - In one example, a system is provided to determine the impact of implementing a change request on a software program. The system may include an architecture model of the software program that includes components. Each of the components may have attributes that may be used by the system to determine a degree of effort to modify each respective one of the components. Components may be associated with keywords. The system may search the change request for the keywords to identify components that may be impacted by the change request. The system may determine the degree of effort to modify any impacted component based on the architecture model. The system may determine the overall impact on the software program based on the degree of effort determined for the impacted components. | 06-17-2010 |
20100153909 | Method and System for Building and Application - A method and system for building an application are provided. The method includes: generating a user model relating to a new application to be built, the user model including at least one role with one or more associated tasks. A task list is compiled for the tasks in the user model, including removing any duplications of tasks. A task to application component mapping is accessed, wherein the application components to which the tasks are mapped are spread over one or more existing applications. The application components mapped to by the tasks are retrieved and compiled in the new application. | 06-17-2010 |
20100162202 | Communication Virtual Machine - A system for automating at least a portion of a communication application development cycle using a communication virtual machine that automatically interfaces with an existing network system and provides an engine for executing designed application models over the existing network system. | 06-24-2010 |
20100175044 | METHOD FOR CREATING SOFTWARE FACTORY FOR DEVELOPING J2EE APPLICATIONS - Methods for creating a factory, such as a software factory, a user experience factory, and a persistence factory, for developing one or more Java 2 Platform, Enterprise Edition (J2EE) applications. One or more artifacts related to the J2EE applications, such as code components, workflow scripts, and build scripts, are identified. Further, one or more templates are created for generating the one or more artifacts. The templates may be created based on a predefined architecture and coding conventions. These templates are stored in a repository to enable their subsequent reuse. Thereafter, one or more relationships between the artifacts are defined in a factory schema. Subsequently, the factory is created using the factory schema and the templates. The factory thus created may be used to develop the J2EE applications. | 07-08-2010 |
20100199257 | Automated Partitioning of a Computation for Parallel or Other High Capability Architecture - A method and a system for transformation-based program generation using two separate specifications as input: An implementation neutral specification of the desired computation and a specification of the execution platform. The generated implementation incorporates execution platform opportunities such as parallelism. Operationally, the invention has two broad stages. First, it designs the abstract implementation in the problem domain in terms of an Intermediate Language (IL) that is unfettered by programming language restrictions and requirements. Concurrently, the design is evolved by specializing the IL to encapsulate a plurality of desired design features in the implementation such as partitioning for multicore and/or instruction level parallelism. Concurrently, constraints that stand in for implied implementation structures are added to the design and coordinated with other constraints. Second, the IL is refined into implementation code. With this invention, porting an implementation neutral computation to an arbitrary architecture can be automated. | 08-05-2010 |
20100211926 | CAPTURING INFORMATION ACCESSED, UPDATED AND CREATED BY PROCESSES AND USING THE SAME FOR VALIDATION OF CONSISTENCY - Techniques for extending a process model with specification of information consumed. A receiving operation receives specification of process information consumed by a process implementation of the process model. Another receiving operation receives specification of activity process information consumed by activities employed by the process implementation of the process model. The information consumed is information that is or needs to be used without being passed through exposed interfaces. A generating operation automatically generates an extended process model using a computer processor. The extended process model includes specification of exposed interfaces, the process information consumed by the process implementation, and the activity information consumed by the activity implementation. Further embodiments includes techniques for identifying information inconsistencies in the extended process model if the information consumed not available as called for by the extended process model. | 08-19-2010 |
20100211927 | WEBSITE DESIGN PATTERN MODELING - Website design pattern modeling technique embodiments are presented that model a website's design patterns. This can be based on the website's layout elements, its URL tokens, or both. When based on both, the design patterns can be modeled separately using first the layout elements and then the URL tokens, or vice versa. Alternately, the modeling can be based on coupled layout and URL token patterns. In operation, the modeling involves first identifying layout elements and/or URL tokens found on at least some of the pages of the website. The website design patterns are then modeled based on the occurrences of the identified layout elements and/or URL tokens in pages of the website. In cases where a coupled modeling scheme is employed, a modeling technique that exploits the correlations between the layout elements and URL tokens is used. | 08-19-2010 |
20100218164 | Pattern Quality Verification Model - Design pattern is redefined to focus on its quality focus. An approach, based on object-oriented quality model, is provides to validate if a design pattern answers whether a proposed structural model of the design pattern really resolves quality problems described in intent of the design pattern. A validation approach is proposed to check if the design pattern is well-designed. In addition, a quantitative method is proposed to measure an effectiveness of quality improvement of the design pattern for determining whether the design pattern is applicable to meet functional and quality requirements. | 08-26-2010 |
20100218165 | OPTIMIZING CODE GENERATION SYSTEM WITH INPUT DATA INTEGRATION - A code generation system is optimized by integrating input data. An input code to the code generation system has a program code and an annotation. The program code is a program text to be automated by the code generation system. The annotation has code generating instructions to process the program code. An input code parser generates a template that parameterizes texts of the program code for automatically generating an output code. The input code parser produces a model to instantiate parameterized program code for each parameter. The template is used as inputs to a template engine of the code generation system and produces a code generator. An output code is created by applying the model to the code generator. | 08-26-2010 |
20100229150 | SOFTWARE TEST BED GENERATION - A system and method is described for generating a test bed that is useful in developing, testing and/or supporting the use of software, such as software used for managing IT processes and/or monitoring equipment in an enterprise network. The system and method operates by processing a manifest to generate an instance space model of a computer network, wherein the manifest refers to a type space model of a computer network and includes an encoding that conveys parameters that are used to inflate the type space model of the computer network into the instance space model of the computer network. The type space model may comprise an object-relational directed graph that describes a plurality of potential directed graph instances and the instance space model may comprise one of the plurality of potential directed graph instances. | 09-09-2010 |
20100229151 | PLATFORM-INDEPENDENT METHOD AND SYSTEM FOR DEPLOYING CONTROL LOGIC PROGRAMMING - A system for generating platform-specific control logic implementation code for execution on a programmable logic controller (PLC) platform includes a plurality of processing layers. A first layer models generic control requirements as a unitary mathematical model (UMM). A second layer translates the UMM into generic control code describing a platform-independent set of generic control functions following an open structured language. A third layer automatically transforms the generic control functions into the platform-specific implementation code executable on different PLC platforms. A method of generating the implementation code includes modeling control requirements as a mathematical model, transforming the model into platform-independent control code describing a predetermined set of generic control functions using Extensible Markup Language (XML) schema, and automatically transforming the generic control functions into the implementation code. | 09-09-2010 |
20100235808 | METHOD AND SYSTEM FOR TASK MODELING OF MOBILE PHONE APPLICATIONS - A system for task modeling interactive sequential applications for one or more mobile devices, which comprises a software tool for defining a generic meta-model of the target applications, wherein the generic meta-model consist of a static model of application components, and a dynamic model of IDs of application screens and connections; a passive TM database for storing the generic meta-model for future reuse, which further comprises static instances of the generic meta-model specifically generated for a variety of mobile devices; a tracker module for real-time monitoring and creating unique ID for each application's screen visited by the user of the mobile device, wherein created IDs are used for generating active models of the user actual use; and an active TM database for storing the active models, wherein data transferring and storing is minimized to screen ID numbers. | 09-16-2010 |
20100251207 | FRAMEWORK FOR VARIATION ORIENTED ANALYSIS FOR SERVICE-ORIENTED ARCHITECTURE - Methods, including service methods, articles of manufacture, systems, articles and programmable devices are provided for performing variation oriented analysis across aspects of service oriented architecture modeling. A commonality or variance of a first process to a second process of an initial model plurality of processes is captured, each having an initial model process format, and also of a third process relative to a fourth process of another model plurality of processes having a different format, wherein the commonalities and variances are stored in a common repository memory device in a repository format different from the model process formats. Processes of a model plurality are then refined as a function of the stored commonalities and variances, wherein refining comprises considering any of the stored commonalities and variances. | 09-30-2010 |
20100251208 | Validating Behavioral Diagrams - In one embodiment, a method includes accessing a first graphical modeling language representation of a system under test. The first graphical modeling language representation includes one or more behavioral diagrams. One or more of the behavioral diagrams includes one or more first conditional constructs. The method includes generating, based on the first representation, a second modeling language representation of the system under test. The second graphical modeling language representation includes one or more Message Sequence Charts (MSCs). One or more of the MSCs includes one or more second conditional constructs that are mathematically equivalent to one or more of the first conditional constructs. The method includes communicating the second graphical modeling language representation for generating one or more use scenarios based on the second graphical modeling language representation. | 09-30-2010 |
20100251209 | Generating Validation Test Suites - In one embodiment, a method includes accessing a modeling language representation of a system under test. The representation includes one or more Message Sequence Charts (MSCs). One or more of the MSCs includes one or more conditional constructs including at least one or more guards or one or more loops. The method includes generating one or more use scenarios based on the modeling language representation and generating one or more validation test suites based on the one or more use scenarios. | 09-30-2010 |
20100269088 | Abstracting Business Logic into Centralized Database Controls - Methods, systems, and products for abstracting business logic into centralized database controls are disclosed herein. In one general embodiment, a method, executed by a computer system, includes identifying data use code in business logic: analyzing the data use code to determine a general data model: and implementing the general data model in the centralized database controls. The general data model is an abstraction embodying the functionality inherent in the data use code. In specific embodiments, identifying data use code in the business logic may be carried out by identifying the data use code in at least one subcomponent of the business logic, such as a user interface code component, a database coding, a table, or a file. The computer system may remove the data use code from the business logic or designate the data use code for removal. | 10-21-2010 |
20100275179 | EXTRACTING A SYSTEM MODELLING META-MODEL LANGUAGE MODEL FOR A SYSTEM FROM A NATURAL LANGUAGE SPECIFICATION OF THE SYSTEM - A system modeling meta-model language model for a system is extracted from a natural language specification of the system. Syntactic structure is extracted from the specification of a system. The syntactic structure represents a set of at least one syntactic subject. A first mapping is created between a predetermined set of the at least one syntactic subject and respective meta-model elements for a system modeling meta-model language. At least one of the meta-model elements is constructed in accordance with the mapping for each identified syntactic subject. The created meta-model structural elements are created for conversion into a model of the system. | 10-28-2010 |
20100281455 | DETERMINING SYSTEM LEVEL DEPENDENCIES - Techniques for co-relating at least one of a functional design and at least one implementation artifact of a solution with at least one infrastructure component of a target deployment environment for the solution are provided. The techniques include obtaining at least one of a functional design and at least one implementation artifact of a solution, obtaining at least one infrastructure component of a target deployment environment for the solution, and co-relating at least one of a functional design and at least one implementation artifact of a solution with at least one infrastructure component of a target deployment environment for the solution, wherein co-relating comprises discovering at least one system level dependency among the at least one of a functional design and at least one implementation artifact and the at least one infrastructure component. | 11-04-2010 |
20100281456 | SYSTEM AND METHOD FOR APPLICATION PROCESS AUTOMATION OVER A COMPUTER NETWORK - A system and a method for automated process management of software in a computer network having a plurality of computers, including for deployment. The automated process management optionally and preferably includes modeling the software application according to one or more requirements of the computer network. The modeling also preferably includes operational modeling. This modeling bridges the gap between development and operation teams. The automated process management is preferably controlled at a management server via a console, such that one or more users may more preferably adjust the process management or at least optionally view progress of any actions within the automated process performance. Such management server preferably enables the software product to be deployed, managed, verified, monitored and tracked from a single location. More preferably, the system and method provide management reports, for generating deployment and/or other automated process management reports for the technical (software professional and/or deployment professional) and management level. | 11-04-2010 |
20100287527 | System Decomposition Via Evolutionary Programming - A technique for generating good system decompositions is disclosed. The illustrative embodiment uses evolutionary programming in combination with a fitness function to generate a system decomposition that has a low degree of coupling and a high degree of coherence. A system is represented by an object-oriented specification using the Unified Modeling Language (UML); the UML specification is then represented by an eXtended Markup Language (XML) document, and the contents of the document are transformed into a nested-list data structure that resembles source code in a functional programming language such as Common LISP. The nested-list data structure and an appropriate fitness function are input to an evolutionary programming engine that operates on the nested-list data structure as though it were a source code program, and generates an output source code program. A system decomposition is then derived from the output source code program. | 11-11-2010 |
20100287528 | Systems and Methods for Modifying Code Generation Templates - Embodiments of the present invention include systems and methods for template reverse engineering. In one embodiment, the present invention includes a computer-implemented method for code generation comprising receiving a template for generating code, receiving a model for generating code, processing the template and the model in a code generator, and in accordance therewith, generating code based on the model and the template, and automatically identifying a common program code construct in two or more of the generated code files. The common code may be automatically extracted from the generated code and embedded in a framework, and the templates may be modified to reference the framework. | 11-11-2010 |
20100299651 | ROBUST TESTING FOR DISCRETE-TIME AND CONTINUOUS-TIME SYSTEM MODELS - A system and method for testing robustness of a simulation model of a cyber-physical system includes computing a set of symbolic simulation traces for a simulation model for a continuous time system stored in memory, based on a discrete time simulation of given test inputs stored in memory. Simulation errors are accounted for due to at least one of numerical instabilities and numeric computations. The set of symbolic simulation traces are validated with respect to validation properties in the simulation model. Portions of the simulation model description are identified that are sources of the simulation errors. | 11-25-2010 |
20100306731 | HIERARCHICAL VIEW STATE STORAGE - Indexing domains of a declarative application with view state information for the domain to enable persisting the view state of the declarative application. The domains are organized in a tree. Each domain is built by a configuration builder. The method includes indexing a domain of a declarative application by indexing a path name in an index. The path name includes a path name of the parent domain of the domain; an identifier of the configuration builder used to build the domain; and an identifier of one or more local decisions made by the configuration builder when creating the domain. The method further includes correlating a unique identifier key to the path name in the index and correlating view state information for the domain to the unique key identifier. | 12-02-2010 |
20100318958 | MANAGING COMPONENET COUPLING IN AN OBJECT-CENTRIC PROCESS IMPLEMENTATION - A method, system, and computer program product for managing component coupling in an object-centric process implementation are provided. The method includes, prior to deriving components that implement a centralized model: analyzing the centralized model to compute couplings within the centralized model resulting in a coupling metric; computing a predicted component model using objects, activities, and the coupling metric of the centralized model; and modifying control flow of the centralized model when a value of the coupling metric exceeds a pre-defined threshold value, re-analyzing the centralized model having the modified control flow, and repeating the computing, modifying and re-analyzing until the coupling metric is less than or equal to the pre-defined threshold. The method also includes implementing an object-centric process having component coupling that is derived from the centralized model when the value of the coupling metric is equal to or less than the pre-defined threshold value. | 12-16-2010 |
20100325603 | COMPUTER METHOD AND SYSTEM FOR ENFORCING DERIVED UNION CONSTRAINTS - A computer method and system preserves derived union constraints and enforces the same in generated target code. The method includes (a) providing a model element having one or more derived union properties, (b) tracking derived union constraints from the derived union properties of the model element, and (c) interpreting the tracked derived union constraints and generating therefrom an implementation that enforces the derived union constraint. Tracking may be by annotating the model element accordingly. | 12-23-2010 |
20100333061 | EXPLICIT STATE MODEL CHECKING OF SL/SF MODELS USING THE AUTO-GENERATED CODE - A system and a method for validating a model for a control system as per a set of specifications. The method includes obtaining a model code corresponding to the model, where the model-code is generated by a modeling tool. Further, a test-code capable of monitoring one or more model parameters that need to be validated is generated using a testing tool. The model-code and the test-code are combined to obtain an integrated-code. The integrated code is executed in the testing tool that compares the obtained output values with the expected output values as provided in the specifications. Further, the model is identified as valid or invalid based on the comparison based on the results of the comparison. | 12-30-2010 |
20110004862 | GENERATING A SERVICE COMPONENT ARCHITECTURE (SCA) MODULE WITH SERVICE ORIENTED ARCHITECTURE (SOA) MODEL ELEMENTS - A system and associated method for generating a Service Component Architecture (SCA) module with Service Oriented Architecture (SOA) model elements. A service model is created according to a process model that has activities and a process flow. Services of the service model are respectively associated with the activities. Each service is determined to employ only one service operation definition to render a message specification of a respective activity that is associated with each service. The activities, the process flow, and the message specification are utilized to produce the SCA module in executable implementations. | 01-06-2011 |
20110010686 | SYSTEM AND METHOD FOR INTEGRATING OBJECT-ORIENTED MODEL PROFILES AND OBJECT-ORIENTED PROGRAMMING LANGUAGES - A method includes receiving a modeling template, the modeling template comprising a plurality of modeling constructs and profile constructs, each profile construct generated from a modeling profile and comprising an extension of one of the modeling constructs. The method further includes parsing the modeling template into the plurality of modeling constructs and profile constructs. One or more object-oriented constructs are defined based, at least in part, on the parsed modeling constructs and profile constructs. Source code is automatically generated in an object-oriented programming language based, at least in part, on the defined object-oriented constructs. The object-oriented programming language comprises an object-oriented programming language with embedded inferencing. | 01-13-2011 |
20110010687 | SYNCHRONIZATION OF CONCURRENTLY MODIFIED INTERDEPENDENT SEMI-DERIVED ARTIFACTS - Described is a method for synchronizing interdependent artifacts that are each modified independent of a modification to the other artifact after a last synchronization. Each artifact has a plurality of elements and is of a different formant from the other artifact. The method includes generating a temporary artifact having all the elements of a last synchronized version of the first artifact and having all the elements of a latest version of the second artifact transformed as the first artifact. The temporary artifact is merged with a latest version of the first artifact to create a synchronized version of the first artifact. A synchronized version of the second artifact having all the elements of the latest version of the second artifact and having all the elements of the synchronized version of the first artifact transformed as the second artifact is generated. | 01-13-2011 |
20110016448 | SYSTEM AND METHOD FOR RAPID DEVELOPMENT OF SOFTWARE APPLICATIONS - The present invention is a system and method for rapid development of software applications comprising: a field composer; a design composer; and a design repository; wherein the field composer is used to create field trees; wherein the design composer is used to create designs; wherein a design is a partial or complete configuration of a software application; wherein one or more data models is/are derived from one or more existing databases; and wherein the design repository stores designs, field trees, and data models. | 01-20-2011 |
20110023008 | METHOD FOR OPTIMIZING AN ARCHITECTURAL MODEL OF A MICROPROCESSOR - A method for optimizing an architectural model of a microprocessor includes representing an instruction set of the microprocessor as a graph by configuring the elements of the instruction set as nodes of the graph. Determination is made whether the nodes with identical bit position and value encoding is present in the graph. If the nodes with the identical bit position and value encoding are present, a path from a source node to a target node is separated into a common node for each node in the graph. The common node is reused to optimize common paths out of the graph and the source node is directly connected to the common node in the graph using a forward edge. A back-edge is added from the common node to the source node through the target node and the above steps are recursively repeated until all the nodes of the graph are processed. | 01-27-2011 |
20110023009 | Computer Software Development Methods And Systems - A method is provided for providing one or more services by a service provider to a service consumer. The method may include defining a meta-model describing at least one core service and at least one compound service; creating a model for the core service based on the meta-model; and implementing the core service on the service provider based on the model. The method may also include implementing the compound service on the service provider and implementing a generic access interface on the service consumer to dynamically access the core service and the compound service. | 01-27-2011 |
20110023010 | RESERVED COMPONENT CONTAINER-BASED SOFTWARE DEVELOPMENT METHOD AND APPARATUS - The invention relates to a software development method and apparatus using Reserved Component Container (hereinafter referred to as “RCC”). An RCC-based software development method comprises designing, data storing (repository), information extraction from the repository, program creation, and testing. An RCC-based software development apparatus comprises: an RCC warehouse ( | 01-27-2011 |
20110035722 | Method for Specifying Stateful, Transaction-Oriented Systems for Flexible Mapping to Structurally Configurable In-Memory Processing Semiconductor Device - A method for specifying stateful, transaction-oriented systems is provided. The method initiates with designating a plurality of primitive FlowModules. The method includes defining at least one FlowGate within each of the plurality of FlowModules, wherein each FlowGate includes a non-interruptible sequence of procedure code, a single point of entry and is invoked by a named concurrent call. An Arc is designated from a calling FlowGate to a called FlowGate and a Signal is generated for each named invocation of the called FlowGate. A Channel is defined for carrying the Signal. Methods for synthesizing a semiconductor device and routing signals in the semiconductor device are provided. | 02-10-2011 |
20110041117 | COMPOSITIONAL MODELING OF INTEGRATED SYSTEMS USING EVENT-BASED LEGACY APPLICATIONS - The compositional event based modeling of integrated applications (CINEMA) tool provides a way to extend a modeling environment using legacy event based applications, such as Graphical User Interface (GUI) APplications (GAPs). CINEMA allows modelers to extend the toolbox of the modeling environment by creating modeling elements that represent GUI objects of GAPs. CINEMA generates source code that allows an integrated system to control and manipulate the GUI objects of GAPs represented by the modeling elements used to create a model of the integrated system. | 02-17-2011 |
20110047525 | QUALITY-DRIVEN ETL DESIGN OPTIMIZATION - A method for quality objective-based ETL pipeline optimization is provided. An improvement objective is obtained from user input into a computing system. The improvement objective represents a priority optimization desired by a user for improved ETL flows for an application designed to run in memory of the computing system. An ETL flow is created in the memory of the computing system. The ETL flow is restructured for flow optimization with a processor of the computing system. The flow restructuring is based on the improvement objective. Flow restructuring can include application of flow rewriting optimization or application of an algebraic rewriting optimization. The optimized ETL flow is stored as executable code on a computer readable storage medium. | 02-24-2011 |
20110047526 | METHOD AND A SYSTEM FOR TRANSFORMING AN OBJECT MODEL - In a method and a system for transforming an object model by executing a transformation workflow consisting of transformation step instances (TSI), the transformation workflow is automatically generated on the basis of transformation artifacts (TA) produced or used as inputs by transformation step instances (TSI) derived from pre-defined transformation step templates (TST). | 02-24-2011 |
20110055800 | Extensible Template-Based Code Generator Builder - A system, method, and computer program product are provided for producing aspects of a generation model. These include a domain model having one or more elements, and templates defined for the elements. The generation model is used to compile a code generator, which can be used to generate code from an input conforming to the domain model. | 03-03-2011 |
20110055801 | INDUSTRY STANDARDS MODELING SYSTEMS AND METHODS - A method of developing a repeatable state-specific Medicaid management information system model includes creating a single Medicaid IT Architecture (MITA) Framework model around a Medicaid IT Architecture standard; creating a single Medicaid management information system model from the MITA Framework model; and creating at least one state-specific Medicaid management information system model from the Medicaid management information system model. The step of creating at least one customer-specific model is repeatable to create additional, different customer-specific software models. | 03-03-2011 |
20110055802 | INDUSTRY STANDARDS MODELING SYSTEMS AND METHODS - A method of developing a repeatable state-specific Medicaid management information system model includes creating a single Medicaid IT Architecture (MITA) Framework model around a Medicaid IT Architecture standard; creating a single Medicaid management information system model from the MITA Framework model; and creating at least one state-specific Medicaid management information system model from the Medicaid management information system model. The step of creating at least one customer-specific model is repeatable to create additional, different customer-specific software models. | 03-03-2011 |
20110066999 | Method of Generating and Distributing A Computer Application - Embodiments of the invention provide methods and systems for producing custom computer applications. A processor ( | 03-17-2011 |
20110072410 | EMF MODEL SYNCHRONIZATION METHOD AND SYSTEM - Provided are an EMF model synchronization method and system. The system calculates a weight based on a hierarchy for an object identifier in a changed model, when the change of the model occurs in an EMF model which has an XML element path as an attribute. The system accumulates the calculated weight to a sum of weights. When the sum of weights becomes greater than the threshold value, the system simultaneously updates all models which are changed until the sum of weights becomes greater than the threshold value, thereby synchronizing change contents. As a hierarchy of an identifier changed on an XML path becomes higher, the weight is determined to have a larger value. | 03-24-2011 |
20110078650 | VALIDATION OF PROCESS MODELS - In computer-implemented methods to validate process models, the models carry semantic information that is related to the process steps, including pre-conditions that indicate whether a step would be executable under certain conditions and post-conditions relating to results from executing a step. Steps are related as predecessor/successor so that a post-condition of the predecessor step can be the pre-condition of a successor step. During model validation, variables are exchanged and propagated between the step conditions. Instead of validating the model for potentially all initial values of variables and conditions, the system identifies portions of the model that can be validated separately for a reduced set of initial states. | 03-31-2011 |
20110088010 | CONVERTING AN ACTIVITY DIAGRAM INTO CODE - An activity diagram can be converted into code, by traversing the activity diagram to identify the cycles in the activity diagram. Each identified cycle can be stored in a list of cycles. Intermixed cycles among the list of cycles can be resolved. When resolving, the identified cycles can be compared one to another to determine if they have common nodes. If so one of the cycles can be removed from the list of cycles. The other cycle can be labeled as a GOTO loop. The activity diagram can be traversed. For each traversed node, code statements can be generated based on the node type and the labels associated with the node. | 04-14-2011 |
20110093834 | USING INFEASIBLE NODES TO SELECT BRANCHING VARIABLES - An optimization engine identifies an infeasible node in a tree data structure that corresponds to a programming model, and computes a fake objective value for the infeasible node. The optimization engine then updates a branching variable pseudocost using the fake objective value. Next, the optimization engine uses multiple branching variable pseudocosts corresponding to multiple branching variable candidates in order to select one of the branching variable candidates. In turn, the optimization engine branches to the corresponding branch of the selected branching variable. | 04-21-2011 |
20110107295 | Automatically Generating Artifacts for Service Delivery - Techniques for generating one or more artifacts for service delivery are provided. The techniques include receiving one or more service design inputs, using the one or more service design inputs to generate an internal representation of the service design, using the internal representation of the service to generate one or more artifacts of the service, and incorporating the one or more artifacts into the service design and outputting the service. | 05-05-2011 |
20110113402 | REPRESENTING NON-FUNCTIONAL REQUIREMENTS (NFRS) IN UNIFIED MODELING LANGUAGE (UML) - Modeling non-functional requirements (NFRs) in a computer programming environment. In one aspect, this further comprises: identifying use case (UC) artifacts having one or more NFRs; retrieving the one or more NFRs and any data associated therewith; analysing the associated data to define a test case therefor; retrieving a UC realisation from a model to determine one or more possible program flows; and testing each possible program flow to select the test case which verifies the use case required, thereby modeling the NFR. | 05-12-2011 |
20110138353 | Procedure And Development Environment For Generation Of An Executable Overall Control Program - A procedure for generating an executable overall control program such as a measurement, control, regulation and/or calibration is illustrated and described for controlling a control system having at least one electronic processor unit, whereby multiple functional model components of one of the functional models describing the functionality of the overall control program are compiled in data code, the data elements used in the functional model components are listed at least partially in one of the various data element sets of the functional model. References between data elements in the data element set and those functional model components of the functional model in which the data elements are used are registered, and these references are saved as additional reference information. Such data elements in the data element sets, which are assigned to multiple functional model components are grouped as common data elements in at least one data element group, and at least a part of the data elements in the data element set is compiled to data code. The data code for common data elements is generated from the data set independently of the functional model, and the function code and the data code are completely merged and compiled into the executable overall control program using the reference information consistently. | 06-09-2011 |
20110145782 | INTEGRATING SOFTWARE COMPONENTS IN A SOFTWARE SYSTEM USING CONFIGURABLE GLUE COMPONENT MODELS - A method that includes: modeling a software system having pairs of coupled software components to yield a platform-independent model of pairs of respective platform-independent software component models associated with platform-specific software components; applying a materialization process to the platform-independent model to yield a platform-specific model by selecting respective concrete platform-specific software components for the software component models; analyzing the platform-specific model to identify mismatched pairs of concrete platform-specific software components; re-modeling the platform-specific model such that each identified mismatched pair becomes coupled together via a configurable glue component model which comprises interface maps usable to eliminate the mismatch; configuring the glue component models by determining, in response to a feedback from a user, code snippets associated with any of the interface maps; and transforming the configured glue component model into a computer code in the platform-specific language by assembling all determined code snippets into a single piece of code. | 06-16-2011 |
20110154286 | .NET RIBBON MODEL FOR A RIBBON USER INTERFACE - An object model is provided that allows .NET developers to customize the Office Ribbon user interface according to a .NET Ribbon model rather than the Ribbon XML/callback model of Office applications. The .NET Ribbon model implements the IRibbonExtensibility interface and provides properties and events for Ribbon components. At runtime, the .NET Ribbon model generates and provides an Office application or document with the XML needed to render the custom Ribbon user interface. A visual designer tool uses the .NET Ribbon model to provide .NET developers with a component view architecture that allows developers to set component properties and generate events. | 06-23-2011 |
20110179397 | SYSTEMS AND METHODS FOR METAMODEL TRANSFORMATION - Some aspects relate to systems and methods to receive a first metamodel conforming to a first meta-metamodel associated with first modeling unit types. A second metamodel conforming to a second meta-metamodel is generated based on the first metamodel and on a mapping between the first meta-metamodel and the second meta-metamodel, where the second meta-metamodel is associated with second modeling unit types, and where the first modeling unit types are different from the second modeling unit types. | 07-21-2011 |
20110185339 | AUTOMATING THE CREATION OF AN APPLICATION PROVISIONING MODEL - An application provisioning model is automatically created. The model is created from a high-level application and specifies dependencies of the application. It is used to provision the application on one or more nodes or other actions. | 07-28-2011 |
20110185340 | SOFTWARE MODELING FRAMEWORK - A system and method for providing a software modeling framework which supports different types of dependency injection and other software modeling or software development frameworks, and which allows software developers to develop models that strategically layer different components for different implementations. A service provider interface (SPI) enables different DI frameworks to be incorporated into the system; while an application provider interface (API) enable machines or implementations to be constructed. Extenders can be modeled so that, for example a particular bundle requires a handler for a particular configuration manifest entry; while a particular module provides handling of that manifest entry. | 07-28-2011 |
20110191748 | SYSTEMS AND METHODS FOR DESIGN TIME SERVICE VERIFICATION AND VALIDATION - Design principles of services ensure reliability, scalability and reusability of software components. Services that follow the design principles are robust to changes and are largely reusable in multiple scenarios but in similar domains. To-date there is no systematic approach to apply these design principles to service design that will ensure service quality. Embodiments of the invention provide a formal check for the adherence of the services designed for an enterprise solution to the service orientation principles using design diagrams. | 08-04-2011 |
20110197174 | Method, System and Computer Readable Medium for Generating Software Transaction-Level Modeling (TLM) Model - The present invention discloses a system for generating a software TLM model, comprising a processing unit; a compiler coupled to the processing unit to generate target binary codes of a target software; a decompiler coupled to the processing unit to decompile the target binary codes into high level codes, for example C or C++ codes, to generate a functional model of the target software, wherein the functional model includes a plurality of basic blocks; an execution time calculating module coupled to the processing unit to calculate overall execution time of the plurality of the basic blocks of the functional model; a sync point identifying module coupled to the processing unit to identify sync points of the software transaction-level modeling model; and a time annotating module coupled to the processing unit to annotate the overall execution time of the basic blocks and the sync points into the functional model to obtain the software transaction-level modeling model. | 08-11-2011 |
20110219354 | Method and Apparatus for Service-Oriented Architecture Process Decomposition and Service Modeling - Techniques are provided for service-oriented (SOA) process decomposition and service modeling. In one aspect of the invention, the techniques include identifying meta-data entities, attributes of the meta-data entities and relationships between stereotypes of the meta-data model, managing the meta-data model for creating, modifying and removing modeling artifacts, and creating modeling templates from the meta-data model to facilitate addressing at least one need of industry-specific applications. In another aspect the invention, the techniques include packaging the method for SOA process decomposition and service modeling, facilitating lifecycle management of modeling assets, and facilitating maintenance of the modeling assets. | 09-08-2011 |
20110239183 | DERIVING PROCESS MODELS FROM NATURAL LANGUAGE USE CASE MODELS - One or more process models from natural language use case models are derived, for example, by creating, using a processor, an in-memory model of a use case from information in natural language text describing the use case; transforming the in-memory model into a process model in predetermined modeling notation; and generating a selected business process model using the process model. | 09-29-2011 |
20110239184 | CAPTURING AND UTILIZING SPECIFIC MODULE DEPENDENCY INFORMATION - Systems and methods are described for capturing and utilizing specific module dependency information. A hierarchical model can be created to arrange the components an existing software system in a particular hierarchy. The model defines a priority of dependencies among the components. A tool is provided for analyzing each class file of the system for references to other class files and determining, for each said class file, whether each reference is acceptable according to the hierarchical model. Once the class files and references have been analyzed, a surrogate class file can be automatically generated for the references that are determined to be unacceptable according to the hierarchical model. This process can utilize white lists and black lists associated with the class files, where the white lists specify modules to which references are acceptable and the black lists specify modules to which references are unacceptable. | 09-29-2011 |
20110246960 | METHODS FOR SOFTWARE MASS PRODUCTION - A model-oriented programming method for computer-based software system development and management. The method includes (a) obtaining the program problem specifications, (b) building a model of the software system, (c) segmenting the model into model segments, wherein each of the model segments is assigned to a programmer, (d) writing a code for each of the model segments, wherein the code implements the assigned model segment, (e) running a model-driven dry-run and upon detection of a model error fixing the error and proceeding with step (c), (f) debugging the code by each of the programmers and upon detection of a model error fixing the error and proceeding with step (c), (g) integrating the code corresponding to each of the model segments into a computer-based software system, and upon detection of a model error fixing the error and proceeding with step (c), and (h) delivering the integrated computer-based software to the client. | 10-06-2011 |
20110252396 | GENERATING EXCEPTION-BASED COMPONENT MODELS FROM NON-EXCEPTION-BASED MODELS - Exception-based component models can be generated from non-exception-based models. For example, a non-exception-based interface contract (such as a non-exception-based interface contract in a header file) for a consumable software component can be parsed. Additionally, a wrapper for the consumable software component can be generated from the non-exception-based interface contract. The wrapper can have an exception-based interface contract implementation, and the exception-based interface contract implementation can be a mirror equivalent of the non-exception-based interface contract. If the non-exception-based interface contract hints at one or more arguments as being out argument(s) for a function in the consumable software component, then predefined heuristics can be used to select one of those argument(s) to be used by the exception-based interface contract implementation as a return value for the function. | 10-13-2011 |
20110252397 | METHOD OF PROVIDING AUTONOMIC MANAGEMENT OF SOFTWARE SYSTEM, RECORDING MEDIUM STORING PROGRAM FOR PERFORMING THE SAME, AND SYSTEM HAVING FUNCTION OF AUTONOMIC SOFTWARE MANAGEMENT - Provided are a method of providing autonomic management of a software system, a recording medium storing a program for executing the method, and a system having a function of autonomic software management. When a request for a service is received from a user, all configurations of a system capable of providing the requested service are obtained from a dynamic feature model, a configuration corresponding to the requested service is obtained among all of the obtained configurations on the basis of a previously set policy to reconfigure resources of the system, and the requested service is provided on the basis of the reconfigured resources. Accordingly, it is possible to provide a service optimized for an environment that varies in real time without user intervention. | 10-13-2011 |
20110252398 | METHOD AND SYSTEM FOR GENERATING VOCAL USER INTERFACE CODE FROM A DATA METAL-MODEL - A method, computer program and system for generating code of the vocal interface of a software application by reading the persistent data of an application designed by a data meta model using a design language such as UML (Unified Modeling Language) defining a hierarchical organization of classes, their attributes and the relations between classes. | 10-13-2011 |
20110252399 | CONFIGURABLE JAVA SERVER PAGES PROCESSING FRAMEWORK - A method, apparatus, and computer instructions for a configurable JavaServer pages processing framework to process JavaServer pages (JSP). A JSP document or page is translated into a document object model (DOM) object that encapsulates elements of the JSP. The syntax of the JSP is validated by a JSP translator with built-in classes and errors are returned if necessary. A JSP visitor configuration file, which defines user configured classes and sequence of execution, is used by the JSP translator to invoke methods of user-defined classes in the order specified by the user to process or visit elements of the DOM object. Result of user-defined class processing may be passed from one class to another within the set. | 10-13-2011 |
20110265060 | Performance-Related Decision Support For Compositions Of Process Modeling Environments - Multiple development models of software applications utilizing different service environments may be annotated with additional information and transformed within a transformation chain into a resulting unified performance analysis model that may be used to evaluate the development models, for example, for simulations and/or analytical sensitivity analysis by utilizing different performance analysis environments. By relating elements of the development models through the transformation chain to elements of resulting unified models, the evaluation may be performed with respect to the resulting/transformed model, but provided to a user in terms of the original development models. In this way, a user of the development models may work with the more-familiar development models, utilizing multiple different performance analysis tools, without having to alter the development models directly in order to obtain the evaluation. | 10-27-2011 |
20110271246 | SOFTWARE DEVELOPMENT SUPPORT TOOL - A software development support tool includes a software model reader configured to read a software model, a software model design intent extractor configured to extract a developer's design intent described in the software model, a source code generator configured to output a source code based on generation rule information, a source code reader configured to read a source code, a source code design intent extractor configured to extract a developer's design intent described in the source code, a software model generator configured to output a software model based on generation rule information, a rule database section configured to accumulate and manage portions of rule information, a database update manager, and a rule modifier. | 11-03-2011 |
20110296373 | COMMAND LINE SHELL COMMAND GENERATION BASED ON SCHEMA - A code generator tool capable of creating command shell commands at compile time or runtime from a schema such as an XSD schema is provided. The code generator generates classes to represent data defined by a schema and the command shell generation code may use knowledge of the classes to generate appropriate command shell classes to manipulate the data. Plug-ins may be inserted following optimization of a model of classes generated by the code generation tool. The plug-ins can modify the model, insert their own code, or disable code generation and generate their own code from the model. | 12-01-2011 |
20110296374 | CUSTOM LANGUAGE MODELS - Systems, methods, and apparatuses including computer program products for generating a custom language model. In one implementation, a method is provided. The method includes receiving a collection of documents; clustering the documents into one or more clusters; generating a cluster vector for each cluster of the one or more clusters; generating a target vector associcated with a target profile; comparing the target vector with each of the cluster vectors; selecting one or more of the one or more clusters based on the comparison; and generating a language model using documents from the one or more selected clusters. | 12-01-2011 |
20110302550 | Providing Diverse Solutions Using Design Space Exploration - A design space exploration (DSE) system automatically discovers viable solutions within a design space. The DSE system operates by creating or receiving a design specification that is described using a design language. The design specification contains a collection of constraints that an acceptable architecture is expected to satisfy. The DSE system then symbolically executes the design specification to provide a logical formula. The DSE system then interacts with a theorem prover module to identify one or more solutions to the formula. Finally, the DSE system converts the solutions into a user-interpretable form (e.g., expressed in the format of the modeling language) for viewing by a user. Each solution pertains to an architecture that satisfies the collection of constraints. The DSE system ensures that the solutions are diverse by disfavoring any solution that is deemed similar to any solution that has been previously encountered. | 12-08-2011 |
20110307856 | WORKFLOW VISUALIZATION - A mechanism is provided for saving workflow execution state and mapping the execution state to graphical elements overlaid on a graphical drawing representing the workflow generated by a separate application. The graphical drawing may be a flowchart drawing corresponding to one or more paths of the workflow and the graphical elements may provide status information associated with individual steps or groups of steps of the workflow execution. | 12-15-2011 |
20110307857 | SYSTEM AND METHOD FOR MANAGING RESOURCES USING A COMPOSITIONAL PROGRAMMING MODEL - A model is provided for managing resources in a programming environment. A first construct is triggered to update mutable entities in response to changes to related data associated with the mutable entities. In accordance with the updated mutable entities, at least one of a second construct and a third construct is triggered to respectively create a new mutable entity and update a data relationship. | 12-15-2011 |
20120005644 | MODULARIZING STEPS WITHIN A UML USER MODEL INTERACTION PATTERN - User modeling facilitates use of a UML user model to define roles, goals, and tasks inside an organization, and defines how the roles, goals, and tasks relate to business entities within the organization. This information can be used to generate a user interface (UI) that facilitates management of the defined business entities within the organization. Each task defined inside the model, which may be represented as a stereotyped class in the UML class diagram, has a number of explicit steps associated with the task. These steps are outlined in UML activity diagrams and defined in a task interaction pattern. A modular approach to constructing UML activity diagram using the task interacting pattern to reduce the size of the model permits greater flexibility in generating the UI. | 01-05-2012 |
20120005645 | METAOBJECT ENHANCEMENT OBJECTS - A system may include acquisition of metadata defining a first object model, the first object model comprising an instance of a metaobject, acquisition of enhancement object metadata defining one or more enhancements to the first object model and associating each of the one or more enhancements with one of one or more stable anchors of the first object model, and creation, based on the metadata defining the object model and the metadata defining the one or more enhancements, of metadata defining an extended object model, the extended object model comprising an instance of the metaobject. | 01-05-2012 |
20120011487 | MODEL VERIFICATION SYSTEM, MODEL VERIFICATION METHOD, AND RECORDING MEDIUM - A model verification system includes a formal language conversion part operable to convert model figure data registered as a design pattern in association with a program into formal language expression data based upon an expression format of a predetermined formal language, and a formal language increment part operable to add a modification to a component of the formal language and/or attribute information on the formal language expression data converted by the formal language conversion means to generate formal language expression data of a derivative design. The model verification system conducts refactoring. | 01-12-2012 |
20120017196 | SYSTEM, ARCHITECTURE AND MICRO-ARCHITECTURE (SAMA) REPRESENTATION OF AN INTEGRATED CIRCUIT - Systems and methods are disclosed to automatically generate a custom integrated circuit (IC) design by receiving a specification of the custom IC including computer readable code to be executed by the custom IC; generating an abstraction of the IC as a system, processor architecture and micro-architecture (SAMA) representation; providing the SAMA representation to a data model having at least an architecture optimization view, a physical design view, and a software tool view; optimizing the processor architecture by iteratively updating the SAMA representation and the data model to automatically generate a processor architecture uniquely customized to the computer readable code which satisfies one or more constraints; and synthesizing the generated architecture into a computer readable description of the custom integrated circuit for semiconductor fabrication. The foregoing can be done with no or minimal human involvement. | 01-19-2012 |
20120017197 | METHOD AND APPARATUS FOR ELECTRONIC SYSTEM MODEL GENERATION - A method of transmitting data is disclosed. At least one system block of a system-on-chip (SoC) is modeled at an untimed functional level in first and second untimed functional models. First and second transaction level (TL) models of the at least one system block system block are modeled at a transaction level (TL) using the first and second untimed functional models, respectively. First and second cycle accurate (CA) models are modeled at a cycle accurate (CA) level using the first and second TL models, respectively. Data is transmitted from the first untimed functional model to the first CA model, from the first CA model to the second CA model via a CA bus, and from the second CA model to the second untimed functional model. | 01-19-2012 |
20120042299 | MODEL TRANSFORMATION UNIT - The invention concerns a model transformation unit adapted to transform a first source model in a source domain into a target model in a target domain, the first source model being a tree of source elements and the target model being a tree of target elements representing a project to be implemented in computer code, the model transformation unit including at least one memory adapted to store the first source model ( | 02-16-2012 |
20120047483 | Smart Web Service Discovery - The present disclosure involves software and computer implemented methods for smart discovery of web services. One process includes operations for identifying a modeled service composition at design time in an integrated development environment (IDE), receiving a selection of an input/output of a first service included within the modeled service composition, collecting a set of information associated with the first service and the selected input/output, searching at least one service repository for a set of services associated with the selected input/output based at least in part on the collected set of information associated with the first service and the selected input/output, presenting at least a portion of the set of services responsive to the search, receiving a selection of a second service from the presented set of services, and integrating the selected second service into the modeled service composition. | 02-23-2012 |
20120047484 | DECORATED MODEL ARCHITECTURE FOR EFFICIENT MODEL-DRIVEN APPLICATION DEVELOPMENT - A computer-executable application is provided with access to resources generated using a principal model. A decoration model associated with said principal model is instantiated for use by the application. The application is provided with access to an object of the decoration model responsive to a request by the application to access an object of the principal model. The decoration model object corresponds to the principal model object. | 02-23-2012 |
20120066661 | VERIFYING PROGRAMMING ARTIFACTS GENERATED FROM ONTOLOGY ARTIFACTS OR MODELS - A transformation tool and a validation tool are used to verify programmable artifacts, such as Java models, that are generated from an original ontology model. The verification process ensures that the programmable artifacts are semantically equivalent to the original ontology model from which they are created. Each element in the programmable artifacts is tagged with appropriate metadata, using, for example, Java language annotation support. Once tagged, the programmable artifacts can be parsed to form a generated ontology model. This generated ontology model can then be compared to the original ontology model with a validation tool, in order to verify their semantic equivalence. | 03-15-2012 |
20120066662 | SYSTEM AND METHOD TO VALIDATE AND REPAIR PROCESS FLOW DRAWINGS - Disclosed is a system and method for validating and repairing flow diagrams using a process modeling validation method in conjunction with a process modeling repair method. The process modeling validation method points out structural ambiguities in a flow diagram that can make its automatic interpretation difficult. It also proposes fix to resolve such ambiguities. The method discloses a process semantic annotation scheme that can interpret process semantics in a flow graph implicit in a flow diagram. Further, the validation process compares one or more components of one or more drawings to a set of rules determined by a business process modeling standards and provides a set of semantic errors describing faulty parts of the drawing that do not comply with the business process modeling standards. The process modeling repair method corrects the drawing to ease and enable its automatic interpretation of the flow diagram and make the faulty parts of the drawing comply with the business process modeling standards. | 03-15-2012 |
20120066663 | Modeling A Governance Process Of Establishing A Subscription To A Deployed Service In A Governed SOA - Modeling a governance process of establishing a subscription to a deployed service in a governed Service Oriented Architecture (‘SOA’) and generating, in dependence upon the modeled governance process, one or more automation modules, each automation module comprising a module of computer program instructions that, when executed by a computer processor, supports performance of one or more steps of the modeled governance process, where the modeled governance process includes collecting available service artifacts associated with a deployed service; determining whether the deployed service meets predefined functional requirements; if the deployed service meets the predefined functional requirements, determining whether the deployed service meets predefined non-functional requirements if the deployed service meets the predefined non-functional requirements, creating a subscription request; requesting approval of the subscription request; and if approval is received, creating a subscription to the deployed service. | 03-15-2012 |
20120072884 | CONVERTING BUSINESS PROCESS MODELS TO COMPONENT MODELS IN A SERVICE ORIENTED ARCHITECTURE DOMAIN - Process artifacts and elements in a business process model, such as a Business Process Modeling Notation (BPMN) compliant model, may be analyzed, converted into component model building blocks for developing applications, and enriched with technical metadata. The component model building blocks may be Service Component Architecture (SCA) Assembly Model building blocks, which may include artifacts, components, composites, and other elements. The building blocks may be structured in an output file, which may be a Simple Capabilities Description Language (SCDL) file, according to the Service Component Architecture (SCA) Assembly Model based on an order provided in the business process model. Business process model elements may be mapped to corresponding component model building blocks, such as SCA artifacts, composites, or components, through a lookup table or database. | 03-22-2012 |
20120079450 | END TO END AUTOMATION OF APPLICATION DEPLOYMENT - Automatic deployment of an information technology (TT) system instance having hardware and software components. An application model of the software components is generated based on use cases and is associated with functional and non-functional requirements. An infrastructure model of the hardware components is generated based on the application model. The same software component modeling language represents both the application and infrastructure models. A markup language computer file is generated to include a design of the IT system instance and instructions for accessing library-stored assets that specify the hardware and software components. The computer file is exported to a deployment tool for automatic deployment of the IT system instance based on carrying out the instructions. In one embodiment, the impact of a proposed change is identified and managed in real time prior to a deployment of the proposed change. | 03-29-2012 |
20120084747 | PARTITIONED ITERATIVE CONVERGANCE PROGRAMMING MODEL - Methods and systems for iterative convergence include performing at least one global iteration. Each global iteration includes partitioning input data into multiple input data partitions according to an input data partitioning function, partitioning a model into multiple model partitions according to a model partitioning function, performing at least one local iteration using a processor to compute sub-problems formed from a model partition and an input data partition to produce multiple locally updated models, and combining the locally updated models from the at least one local iteration according to a model merging function to produce a merged model. | 04-05-2012 |
20120084748 | SYSTEM AND A METHOD FOR GENERATING A DOMAIN-SPECIFIC SOFTWARE SOLUTION - A method for generating a domain-specific software solution may include receiving a request for a solution model to accomplish one or more tasks. A domain model may be selected in response to the request for the solution model. The solution model may be configured based on the selected domain model. The solution model may be configured by selecting a set of candidate technical assets for each task of the solution model. The solution model may also be configured by determining for each candidate technical asset if the one or more requirements of the task of the solution model are satisfiable by the candidate technical asset. The solution model may be further configured by selecting a technical asset for each task to be included in a solution implementation. | 04-05-2012 |
20120096426 | METHOD OF EXTENSIBLE BUSINESS OBJECT MODELING AND GENERATION OF SYSTEM ARTIFACTS FROM THE MODELS - A method for defining XML-based models of logical type hierarchies, business objects and sub-objects, business object operations, enumerations and reusable structures and field-sets. The method defines an optimal, yet extensible, structure of the object models to simplify the modeling process by capturing the most essential elements of the model and inferring any additional information, such as relationship between objects, during the process of generating code, database scripts or other system artifacts from the model. Methods of generating a relational model and a presentation data model from such a business object model. | 04-19-2012 |
20120110545 | ABSTRACTING TRANSFORMATION FOR MODEL DRIVEN ARCHITECTURE - An example embodiment of the present invention provides a process for abstracting an implementation-independent model to an implementation-specific model during transformation in a MDA system. In the example embodiment, the MDA system comprises a transformation engine whose components might include software tools such as AndroMDA and Muse. The transformation engine accepts as input an implementation-independent model written in a modeling language such as UML that provides graphical notation to describe inheritable classes and their attributes and relationships. The transformation engine also accepts a configuration file which allows the designation of a class in the model as a manageable resource. From these inputs, the transformation engine creates a manageable resource corresponding to the class, which resource includes any subclasses by inheritance from the designated class unless the subclass is specifically excluded in the configuration file. In one embodiment, the manageable resources created by the transformation engine are WSMD manageable resources. | 05-03-2012 |
20120124550 | FACILITATING DATABASE APPLICATION CODE TRANSLATION FROM A FIRST APPLICATION LANGUAGE TO A SECOND APPLICATION LANGUAGE - A method of facilitating code translation from one a first application language to a second application language is provided. This method involves reading information describing the database to a code generation engine and reading database applications associated with the first application language to the code generation engine. The code generation engine may use extractors to generate a database Meta model associated with the first application language and a source database application Meta model associated with the source database application. The code generation engine may then generate second database application code using a code generation engine that applies constructors to the source database application Meta model. | 05-17-2012 |
20120124551 | TEMPLATE INHERITANCE IN A CONFIGURATION OBJECT MODEL - A method for generating templates in a programming environment can include generating a first template having a plurality of object type definitions, defining properties for the object type definitions within the first template and deriving a second template from the first template, wherein the properties of the first template are defined in the second template, wherein the first template includes a link to a template link object in the second template. | 05-17-2012 |
20120131542 | SYSTEMS AND METHODS FOR CREATING REUSABLE SOFTWARE COMPONENTS BASED ON REGULATORY AND POLICY DOCUMENTS TO ENSURE COMPLIANCE WITH THE DOCUMENTS FOR INTEGRATION WITH AUTOMATED SYSTEMS - A computer-assisted method for generating one or more reusable software components that can be invoked by an automated business process to make the automated business process compliant with a regulation is disclosed. According to various embodiments, the method includes the step of analyzing a document containing the regulation to extract use case information and business rules for a sub-process that complies with the regulation. The method may also include the step of developing the reusable software component for the sub-process based on the use case information and business rules. The method may further include the step of storing the reusable software component in a repository such that the reusable software component is invokable by the automated business process. | 05-24-2012 |
20120131543 | METHOD AND SYSTEM FOR CAPTURING USER INTERFACE STRUCTURE IN A MODEL BASED SOFTWARE SYSTEM - Method and system for capturing device-independent user interface structure in a model based software system are disclosed. In one embodiment, at least one entry point is received from a user by a business system. Further, a user interface corresponding to the at least one entry point is provided. Furthermore, user interface meta-data associated with the user interface is captured. Also, at least one event associated with user interface elements is identified as a response to user actions based on the captured user-interface meta-data. In addition, a pattern signature is identified in the model based software system for reuse in one or more model based software systems based on an expected behavior of the user interface when the identified at least one event occurs. Then, the identified at least one event is mapped to the identified pattern signature. | 05-24-2012 |
20120159425 | APPLICATION MODEL FOR IMPLEMENTING COMPOSITE APPLICATIONS - Embodiments are directed to providing an application model for implementing composite applications and to providing a declarative programming model and distributed runtime for creating and executing composite applications. In an embodiment, a computer system instantiates an application model. The application model allows users to compose composite applications. The composite applications are configured to run on both distributed computing systems and local computing systems. The computer system receives user input at the instantiated application model. The user input indicates which composite application components are to be used in conjunction with each other to form the composite application. The computer system also provides the composite application on a distributed computing system and/or a local computing system. | 06-21-2012 |
20120159426 | SYSTEMS AND/OR METHODS FOR CREATION OF METAMODELS - Certain example embodiments described herein relate to systems and/or methods for systems and/or methods for improved creation of metamodels. More particularly, certain example embodiments described herein relate to automating the creation of metamodels from one or more example models. In certain example embodiments, nodes, edges, and multiplicities of at least one model are automatically identified. A preliminary metamodel is created by adding a metaclass for each automatically identified node and edge. A connection is made between each said added metaclass edge to at least two said added metaclass nodes via first and second associations. Detection of multiple relations is performed by determining whether any of said added metaclass edges are connected to more than two added metaclass nodes. The preliminary metamodel is refined or optimized, e.g., so as to reduce the occurrence of multiple relations. | 06-21-2012 |
20120159427 | SYSTEM AND METHOD FOR EXTRACTING UML MODELS FROM LEGACY APPLICATIONS - A method and computer program product are provided for extracting UML models from legacy applications. The system involves extraction of UML models and importing and exporting than to other commercial UML tools. In a more specific aspect, UML objects are associated with business rules which have been extracted from a legacy application. In particular, UML diagrams are extracted from a legacy application for Use Case diagrams, Activity diagrams from screen flows, and Activity diagrams from program logic. | 06-21-2012 |
20120159428 | METHOD OF DETERMINING MULTIMEDIA ARCHITECTURAL PATTERN, AND APPARATUS AND METHOD FOR TRANSFORMING SINGLE-CORE BASED ARCHITECTURE TO MULTI-CORE BASED ARCHITECTURE - A method and apparatus for authoring an architecture for transforming a single-core based embedded software application to a multi-core based embedded software application, and a method of determining an architectural pattern in a multimedia system. It is possible to perform an architecture authoring operation by using an architectural decision supporter, without prior knowledge and accumulated knowledge regarding a software architecture. Additionally, it is possible to prevent an error from occurring during authoring of an architecture, by using a concurrency-related software architectural pattern that is already evaluated. Thus, it is possible to improve overall quality of software, and to reduce a development time. | 06-21-2012 |
20120167035 | APPARATUS AND METHOD FOR DEVELOPING CUSTOMER-ORIENTED EMOTIONAL HOME APPLICATION SERVICE - An apparatus for developing a user-oriented emotional home application service includes: an emotional information collection unit configured to sense a user and a user's surrounding environment through a sensor and collect one or more pieces of emotional information; an emotional home application service platform engine configured to extract contents suitable for the user based on the collected emotional information; and an application service development support unit configured to support various tools including a service modeling tool for developing an emotional home application service. | 06-28-2012 |
20120192143 | DETECTING DESIGN PATTERNS IN MODELS BY UTILIZING TRANSFORMATION LANGUAGE - A mechanism is provided for detecting pattern occurrences utilizing a transformation software application on a computer. An input model is received in which the transformation software application is configured to detect model elements playing pattern roles, and report them in an output model (conforming to new pattern result language). A pattern specification is configured as a declarative transformation relation that is used by the transformation software application to detect pattern occurrences in the input model. Pattern occurrences are reported in the output model, where the pattern occurrences are instances of the pattern detected in the input model. | 07-26-2012 |
20120192144 | MIGRATING UNIFIED MODELING LANGUAGE MODELS ACROSS UNIFIED MODELING LANGUAGE PROFILES - A method and system for migrating a UML model across UML profiles. After retrieving a UML model, a source UML element, a source UML profile, a source stereotype, and a source meta-class, the target UML profile, stereotype and meta-class are looked up in a mapping table based on the source UML profile, stereotype, and meta-class. The target UML profile is applied on the UML model. Based on the source meta-class being different from the target meta-class, relationships of the source UML element are retrieved, a target UML element is created, the relationships are copied to the target UML element, and the source UML element is removed from the UML model. The target stereotype is applied to the target UML element. The source stereotype is removed from the target UML element. The source UML profile is removed from the UML model. | 07-26-2012 |
20120198415 | UNIFIED INTERFACE FOR META MODEL CHECKING, MODIFYING, AND REPORTING - This disclosure provides various embodiments for performing operations on entities of a meta model modeling one or more software components. A request is received to perform a particular operation of a particular type on each of a plurality of model entities, each model entity modeling at least one attribute of a software component. The request includes an identification of the particular type of operation in a plurality of operation types. The model entities are retrieved in response to the request. A handler object is instantiated of the particular type adapted to perform the particular operation by calling a set of reusable software modules, each software module providing functionality used to perform at least a portion of the particular operation on at least one entity in the plurality of entities. Result data is generated based on the performance of the particular operation using the instantiated handler and reusable software modules. | 08-02-2012 |
20120198416 | SUPPORT FOR HETEROGENEOUS DATABASE ARTIFACTS IN A SINGLE PROJECT - A single software project can include heterogeneous types of artifacts. The artifact definition can be converted to a format compatible with a common model or information derived from the artifacts can be added to the common model so that tools that operate on the common model can provide information derived from the heterogeneous artifacts to developers during design time in an IDE. Build and deployment tools can operate over a more inclusive universe of data to provide a more accurate deployment plan. Build and deployment tools can operate within the context of the IDE or from the command line. | 08-02-2012 |
20120210292 | Design and Development of Service-Oriented Architecture (SOA) Solutions - A method is provided for designing and developing an service-oriented architecture solution that comprises implementing a business process layer having a first set of architectural building blocks (ABBs) and configured to perform service composition and service decomposition; implementing a service component layer having a second set of ABBs and configured to perform service integration and service invocation; implementing a service layer having a third set of ABBs and configured to perform service discovery and service aggregation; integrating the business process layer, the service component layer, and the service layer; and specifying a set of characteristics of the first, second, and third sets of ABBs to be reconfigurable based upon extensible rules. | 08-16-2012 |
20120210293 | AGGREGATION OF CONSTRAINTS ACROSS PROFILES - Leveraging profiles to define stereotypes for other profiles introduces efficiency into modeling. Although constraints can be inherited, constraints cannot currently be aggregated across profiles. Aggregating constraints across profiles leverages the labor invested in defining other profiles as well as adding flexibility to defining stereotypes. | 08-16-2012 |
20120216173 | GENERATING A SERVICE-ORIENTED ARCHITECTURE POLICY BASED ON A CONTEXT MODEL - A solution for generating a Service-Oriented Architecture (SOA) policy based on a context model is provided, which generates an application scope of the SOA policy; generates a context model; generates an action list for the context model based on action semantic modules customized by a user; generates a condition part of the SOA policy according to the context module; generates an action part of the SOA policy according to the action list; and combines the condition part and the action part to generate the SOA policy. | 08-23-2012 |
20120233584 | Analysis of Interactions of C and C++ Strings - A computer implemented method for analyzing a computer software program comprising both C++ and C string components, wherein the method includes building a memory model abstraction of any memory used by the program strings. Various memory models are presented that find invalid memory accesses in terms of validity of memory regions and buffer overflows. The model supports analyzing the interaction of C and C++ components—in particular, it focuses on the interaction of C and C++ strings. The conversion of C++ strings to C strings is accomplished through a non-transferable ownership attribute that is to be respected by the C strings. The models can then be analyzed using static analysis techniques such as abstract interpretation and model checking, or through dynamic analysis. In so doing we allow discovery of potential memory safety violations in programs involving conversions between C and C++ strings. | 09-13-2012 |
20120233585 | System Design Combining Functional Decomposition And Object-Oriented Programming - An architecture for designing complex systems includes combining functional decomposition and object-oriented techniques at each level along with specifying links between the levels as well as links between the objects at a level to promote understanding of the system under development and assist both the system design engineers and the hardware and software engineers to develop the system. | 09-13-2012 |
20120233586 | METHODS AND TOOLS FOR DATA-DRIVEN APPLICATION ENGINEERING - The invention generally relates to enterprise computer applications, and more particularly to methods and tools for data-driven engineering of computer applications. A method of generating a business application includes: inputting requirement data into a requirement model; inputting platform data into a platform model; generating a design model based on the requirement model and the platform model; generating source code of the business application from the design model; and outputting the source code. | 09-13-2012 |
20120240098 | Software Development and Publishing Platform - Described are methods, systems, and computer program products for providing a flexible development platform. The system aspect includes a hierarchical data modeling system, which itself includes a number of data modeling system base data types, a structure class comprising one or more complex data types. There is also an encoding module. In the first structure class, each complex data type includes the data modeling system base data types or another structure class. The encoding module converts the one or more complex data types of the first structure class into a form using only the data modeling system base types. | 09-20-2012 |
20120246611 | TRANSFORMATION FRAMEWORK - A transformation framework accesses user story information inputted by a user into a pre-defined template designed to receive a user story and parses the accessed user story information to identify key pieces of the user story. The transformation framework identifies process components needed to implement the software system requirement defined by the user story and generates a process language model for each of the identified process components. The transformation framework maps the key pieces parsed from the user story to the generated process language models to define process language statements that correspond to the software system requirement defined by the user story. | 09-27-2012 |
20120246612 | SYSTEM AND METHOD FOR VERIFICATION AND VALIDATION OF REDUNDANCY SOFTWARE IN PLC SYSTEMS - Formal methods are instituted to verify and validate the finite state machine (FSM) of PLC redundancy software. The method and system is implemented through each phase in the lifecycle of the redundancy software; that is, the requirement phase, design phase, implementation phase and, finally, integration phase (including system integration). At each step along the way, the verification and validation process uses tools such as a checklist-based review and inspection, a requirement traceability analysis, formal verification (model checking) and the like to ensure that the created redundancy software is error-free and will perform as intended when implemented in the redundant PLC system. | 09-27-2012 |
20120254827 | VERIFICATION OF COMPUTER-EXECUTABLE CODE GENERATED FROM A MODEL - In an embodiment, a model is sliced into a plurality of slices. A slice in the plurality of slices is selected. A portion of code, that corresponds to the selected slice, is identified from code generated from the model. The identified code is verified to be equivalent to the selected slice. Equivalence may include equivalent functionality, equivalent data types, equivalent performance, and/or other forms of equivalence between the selected slice and the identified generated code. | 10-04-2012 |
20120254828 | Flexible Modeling Architecture For Management Systems - A flexible modeling architecture is described that allows multiple versions of entities of different types to be modeled in a structured fashion with different model sets, with a variety of functional models, each representing a different aspect of the system and allowing generation of any number of artifacts at build-time as well as run-time to result in rapid creation of consistent computer applications to manage concurrently a plurality of entities, dynamically adjusting to the version of metadata on each entity. | 10-04-2012 |
20120260227 | STATEFUL COMPONENT AUTHORING AND EXECUTION - A method for of authoring and executing stateful components for a distributed application is disclosed. An application schema for the distributed application is declaratively defined and includes a plurality of distributed modules. Each module hosts a set of stateful components co-located in a physical tier of a distributed environment having logic to manipulate state. The runtime supports partitioning the stateful components. Control flow opaqueness of component logic is banished in each of the stateful components, which would otherwise occur if state was externalized. | 10-11-2012 |
20120260228 | COMPOSITE APPLICATIONS USING SERVICE COMPONENT ARCHITECTURE MODEL AND OPEN VIRTUALIZATION FORMAT - Composite applications can be created that utilize a plurality of different services across a plurality of different cloud stack layers. The composite applications are defined using the Service Component Architecture (SCA) model. Composite applications can be translated from the SCA model into a format compatible for a virtualization platform, such as the Open Virtualization Format (OVF). Composite applications, as defined in the format compatible for the virtualization platform, can be deployed on the virtualization platform. | 10-11-2012 |
20120272208 | SYSTEMS AND METHODS FOR PROVIDING AND CUSTOMIZING A VIRTUAL EVENT PLATFORM - Systems and methods for customizing the functionalities and content of virtual event platform are disclosed. Content is received from a user using a template. Within the template the user defines and/or implements calls to an application programming interface to access various functionalities existing within the virtual event platform, as well as system variables exposed by the existing virtual event platform. The user uses the API system variables to define the customizations. | 10-25-2012 |
20120278787 | COLLABORATIVE REALTIME PLANNING USING A MODEL DRIVEN ARCHITECTURE AND ITERATIVE PLANNING TOOLS - Systems and methods are disclosed that include creating a template file with at least one logic unit. These systems and methods also include creating model file with at least one type independent information element. The type independent information has at least two values associated with it. In addition, there are systems and methods interpreting the data comprised within the model file using the template file. A program is created in some embodiments using data that has been created. | 11-01-2012 |
20120284685 | HETEROGENEOUS LANGUAGE DATA TYPING WITHOUT EXECUTABLE REGENERATION - Data typing information for heterogeneous language components is obtained during software development without requiring executable regeneration. After source code is changed, dependent compiled components, which are written in multiple high-level programming languages, are identified. A query engine obtains data typing information of the dependent components, such as function signatures and class definition, directly from internal compiler-created structures for the respective programming languages. Through a synchronizer, a shared model is automatically populated with the data typing information. The updated model supports cross-language software development operations such as autocompletion, refactoring, dependency finding, and definition go-to, without regeneration of an executable code unit which reflects the changed source code. In cases involving SQL or Transact-SQL (T-SQL), a Data Definition Language file can be automatically generated from the data typing information. | 11-08-2012 |
20120291003 | SYSTEM AND METHOD FOR CREATING AND USING GRAPHICAL OBJECT INSTANCES IN A STATECHART ENVIRONMENT - A method of providing multi-instantiable state templates to a statechart environment is discussed. The method includes the step of providing a graphical definition of an independent state machine object belonging to a statechart. The method further includes the step of instantiating a first instance and a second instance of the independent state machine object in the statechart. The method additionally includes the steps of starting execution of the first instance of the independent state machine object and then stopping execution of the first instance of the state machine object. Additionally, the method includes the step of starting the execution of the second instance of the independent state machine object in the state diagram. | 11-15-2012 |
20120297359 | AUTOMATED BUILD PROCESS AND ROOT-CAUSE ANALYSIS - A method automatically integrates tracks into a software build. The method receives a track to be integrated into the software build. The method determines if all tracks dependent upon the received track have been integrated into the software build. If all tracks dependent upon the received tracks are determined to have been integrated, the method automatically creates build scripts according the received track. If not all tracks dependent upon the received tracks are determined to have been integrated, the method notifies owners of the received track and any unintegrated dependent track that there are unintegrated dependent tracks. The method automatically starts build processes according to the build scripts. If all the build processes are successful, the method marks the received track and all the dependent tracks as good and ready for a product build. If not all the build processes are determined to be successful, the method automatically performs root-cause analysis to determine which of the tracks caused a build to fail, automatically marks the track or tracks that caused the build to fail as bad and not integrated. The method automatically notifies an owner of the track or tracks that caused the build to fail of the results of the root-cause analysis. | 11-22-2012 |
20120304148 | VISUAL COMPARISON DISPLAY OF SOFTWARE - In a method for comparing visual programs, a first object model is compared with a second object model, and a first difference object model and in particular a second difference object model are displayed. Differences in the programs are indicated in the difference object models by markings. | 11-29-2012 |
20120311523 | DEPENDENCY-BASED IMPACT ANALYSIS USING MULTIDIMENSIONAL MODELS OF SOFTWARE OFFERINGS - The disclosed embodiments provide a system that facilitates the maintenance and execution of a software offering. During operation, the system obtains model data associated with a multidimensional model of the software offering. Next, the system uses the model data to calculate a set of dependency scores representing levels of dependency among a set of service components and a set of resources used by the software offering. Finally, the system uses the dependency scores to facilitate management of the software offering. | 12-06-2012 |
20120311524 | Gateway Data Distribution Engine - Implementations include a method, system, and apparatus for receiving, from a user communicably connected to a network, a selection of one or more gateway service data categories; receiving, from the user, a selection of an operating platform of a mobile device operable to be communicably connected to the network; generating a configuration file comprising a selection of gateway service data associated with one or more gateway service data categories and the operating platform selection; generating a data store file and a development library associated with the operating platform selection; transferring the configuration file, the data store file, and the development library to a repository communicably connected to the network; and generating an application template comprising the configuration file, the data store file, and the development library, wherein the mobile application is developed on the mobile device from the application template while the mobile device is communicably disconnected from the network. | 12-06-2012 |
20120311525 | APPLICATION MANAGEMENT SYSTEM - An application management system includes a web server including objects including a predefined and preassembled component, the objects forming: a generic organization model composed of logic organizational entities; a generic management model composed of logic operational entities; a generic control model composed of data analysis tools; a generic model of screens and kinematics for a user interface; a set of tables and files characterizing the activation and personalization options of the objects and the processes, streams and rules associated with the objects; tools for identifying possible activations of objects linked to an initial object activation; management tools for building logic networks including data spaces, and preassembled links that can be activated and personalized, each data space may be composed of all the objects, a connector object suitable for searching for tables and files; a data server including a single predefined physical database including data corresponding to the objects. | 12-06-2012 |
20120317542 | SYSTEM AND METHOD FOR CREATING AND UPDATING A DATA MODEL FROM DISPARATE EVENTS RECEIVED ON ARBITRARY APPLICATION THREADS - An abstract component model can be used to drive an editor by providing an underlying stateful model for component implementation without the need to re-implement details. The abstract component model can represent one or more artifacts, wherein the abstract component model contains a plurality of model objects. A lightweight structure model contains a plurality of structure objects, wherein each structure object is a data structure that represents how the abstract component model should look like at the end of an update cycle. Additionally, a model updater can match one or more structure objects in the lightweight structure model to one or more model objects in the abstract component model, and update each said model object in the one or more structure objects based on said one or more structure objects in a top-down, depth-first fashion. | 12-13-2012 |
20120331443 | METHOD AND SYSTEM FOR IDENTIFYING GRAPHICAL MODEL SEMANTICS - A system and method for identifying graphical model semantics, one aspect, receive a graphical diagram, associate each of a plurality of elements with at least one predetermined meta-types, identify a plurality of types in the graphical diagram, and determine a category for each of elements in said graphical diagram. Containment identification rules identify one or more containment relationships in the graphical diagram. Multiplicity identification rules identify multiplicity relationships in the graphical diagram. Advanced semantic rules identify visual elements that represent attributes and refine relationships to identify unique behavior. | 12-27-2012 |
20130007695 | MODELLING SERIALIZED OBJECT STREAMS - Modelling a serialized object stream can include receiving a stream of bytes corresponding to the serialized form of a first object, creating an empty initial model for containing a generic object and a generic class, and, upon detection of a class from the stream, constructing a corresponding generic class object in the model using a processor. Upon detection of a new object from the stream, a corresponding generic object in the model can be constructed. Further objects and classes in the model that are associated with the generic objects and classes can be referenced. | 01-03-2013 |
20130007696 | PRESCRIBING A SOFTWARE ARCHITECTURE FOR IMPLEMENTING SERVICE INTEGRATION - An approach is provided for prescribing a first software architecture to implement service integration. To determine first products, a first weight of a first software architecture is multiplied by weights of first requirements of a service. To determine second products, a second weight of a second software architecture is multiplied by weights of second requirements of the service. The first and second requirements are satisfied, respectively, by first and second sets of responses respectively associated with the first and second software architectures. The first products are summed and the second products are summed to determine first and second summations, respectively. The first summation is determined to be greater than the second summation. Based on the first summation being greater than the second summation, the first software architecture instead of the second software architecture is selected and prescribed to realize the service in a service integration implementation. | 01-03-2013 |
20130019224 | SYSTEMS AND METHODS FOR VERIFYING MODEL EQUIVALENCEAANM Madl; GaborAACI St. Louis ParkAAST MNAACO USAAGP Madl; Gabor St. Louis Park MN USAANM Oglesby; David V.AACI Brooklyn CenterAAST MNAACO USAAGP Oglesby; David V. Brooklyn Center MN USAANM Chakraborty; KuntalAACI SingurAACO INAAGP Chakraborty; Kuntal Singur INAANM Bhatt; DeveshAACI Maple GroveAAST MNAACO USAAGP Bhatt; Devesh Maple Grove MN USAANM Hickman; Stephen OtisAACI MaricopaAAST AZAACO USAAGP Hickman; Stephen Otis Maricopa AZ US - Systems and methods for verifying model equivalence are provided. In one implementation, a system includes: a memory device that stores a reference model (RM) and comparison model (CM), wherein the CM and the RM are constrained by a set of rules; and a processing unit that generates a reference model representation (RMR) from the RM and stores the RMR on the memory device; the processing unit further generates a comparison model representation (CMR) from the comparison model (CM) and stores the CMR on the memory device, wherein the processing unit further to: verifies that the CMR compatibly implements the RMR; verifies that a CM data flow diagram derived from the CMR compatibly implements a RM data flow diagram derived from the RMR; and verifies that every CM semantic unit implements a behavior that corresponds to a RM semantic unit and every RM semantic unit is accounted for in the CM. | 01-17-2013 |
20130055194 | SYSTEM AND METHOD FOR IMPLEMENTING APPLICATION CODE FROM APPLICATION REQUIREMENTS - A method for execution by a processing module begins with receiving application requirements and parameters. The method continues by generating application code based on the application requirements, the parameters, and the feedback. For a current implementation of the application code, the method continues by entering a loop that begins by selecting an implementation tool in accordance with implementation constraints and a previous implementation result. The loop continues by generating a current implementation result based on an application of the implementation tool, one or more of the application requirements, one or more of the parameters, and the previous implementation. The loop continues by receiving current feedback regarding the current implementation result. The loop continues by determining whether the current implementation result is at a desired level of correctness based on the current feedback. When the current implementation result is not at the desired level of correctness, the loop repeats otherwise it is exited. | 02-28-2013 |
20130055195 | SYSTEM AND METHOD FOR ITERATIVE GENERATING AND TESTING OF APPLICATION CODE - A method begins by generating application system state transitions from inputted requirements and parameters. For a current implementation of generating application code, the method continues by entering a loop. The loop begins by generating a current intermediate result based on a previous implementation and in accordance with current application code development factors. The loop continues by generating at least one test case based on the one or more of the application system state transitions. The loop continues by testing the current intermediate result in accordance with the at least one test case. When the testing is unfavorable, the loop continues by modifying one or more of: the one or more of the plurality of application system state transitions, the one or more of the parameters, and the one or more implementation tools. The loop then continues by repeating the loop using the modified current application code development factors. | 02-28-2013 |
20130055196 | GENERATING PLC CODE FROM CAD MODELS - Product data management systems, methods, and mediums. A method includes receiving a functional model, and identifying a plurality of elements of the functional model. Each element corresponds to one or more machine operations. The method includes identifying concurrencies between elements to determine at least one set of elements. The method includes creating an execution thread for each of the sets of elements. The method can include generating a rule-based programmable logic controller (PLC) program corresponding to the functional model, based on the execution threads. | 02-28-2013 |
20130061204 | GENERATED OBJECT MODEL FOR TEST AUTOMATION - A generated object model engine abstracts actions, used in test cases, in a manner to produce new object model types that are independent of an underlying code implementation. The generated object model engine analyzes action classes to aggregate a set of actions having similarly-related class types. Action classes having similarly-related class types are then used to form a new object model type. The new object model type may be used in a test case to hide the action's code implementation from the test case. | 03-07-2013 |
20130080993 | EMBEDDED SYSTEM PERFORMANCE - A method of generating an embedded system ( | 03-28-2013 |
20130086547 | REAL-TIME OPERATIONAL REPORTING AND ANALYTICS ON DEVELOPMENT ENTITIES - Methods and apparatus, including computer program products, are provided for reporting and analytics for development entities. In one aspect, there is provided a computer-implemented method. The method may include selecting a development entity model for generating a report including development information regarding the development entities corresponding to the selected model, the development entity model representing an element being developed for a system; configuring a report model for the selected development entity model to enable creation of the report model; and saving the report model for the selected development entity model, the saved report model stored with other report models defining other reports for operational business objects used in conjunction with the system. Related apparatus, systems, methods, and articles are also described. | 04-04-2013 |
20130091486 | GENERATING A COMPLIANCE DATA MODEL FOR IT CONTROL - Techniques are described herein that are capable of generating a compliance data model for information technology (IT) control. The compliance data model is capable of capturing data from technologies (e.g., software programs, file systems, etc.) and/or developers of those technologies for determining compliance of the technologies with regulations. The compliance data model may be used to automate generation of artifacts. Each artifact is machine-readable code that includes instructions regarding how to implement a control. A control is a software container that is associated with one or more elements, such as a control objective, a control activity, a control activity test, etc. The artifacts are usable by management systems to obtain data regarding installed technologies, settings of the technologies, configurations of the technologies, events that are being utilized by the technologies, etc. The management systems may use the data to generate reports regarding compliance of the technologies with the regulations. | 04-11-2013 |
20130097579 | OPERATIONAL MODEL CREATION FROM SOA SOLUTION ARCHITECTURE - A method for creation of an operational model from a service oriented architecture (SOA) solution architecture. The method includes: selecting an SOA solution architecture model from a plurality of SOA solution architecture models including a plurality of layers; retrieving at least one layer according to the SOA solution architecture model; retrieving at least one SOA model element corresponding to the at least one layer; searching for an operational model element type for the at least one SOA model element and reading the operational model element type; reading a technical environment including hardware, operating system and software product requirements for the operational model element type; creating an operational model element with the technical environment hardware, operating system and software product requirements; and generating an operational model including the specific hardware and software infrastructure required to deploy the SOA solution architecture solution. The method is performed on one or more computing devices. | 04-18-2013 |
20130097580 | ASYNCHRONOUS PROGRAMMING MODEL MAPPING - Mapping is performed between operations of an abstract asynchronous programming model and a concrete asynchronous programming model. In other words, differences between asynchronous programming models are bridged to enable interaction. | 04-18-2013 |
20130097581 | METHOD FOR RECORDING DATA, DEVICE, AND CORRESPONDING COMPUTER PROGRAM PRODUCT - The invention relates to a process for recording a plurality of data items constituting at least one entity. | 04-18-2013 |
20130104099 | SELECTIVE CHANGE PROPAGATION TECHNIQUES FOR SUPPORTING PARTIAL ROUNDTRIPS IN MODEL-TO-MODEL TRANSFORMATIONS - Certain example embodiments relate to selective change propagation techniques for supporting partial roundtrips in model-to-model transformations. In certain example embodiments, enablement checking is performed to determine whether a propagation operation can be performed for an object. If the object passes enablement checking, the propagation is executed by, for example, creating the object(s) in a business-oriented (e.g., EPC) model; updating relevant internal attributes of technical (e.g., BPMN) objects that allow for the successful merge; optionally correcting user-introduced errors in the technical model; and properly connecting the pulled-up objects with their surroundings. The connecting is performed so that the objects advantageously appear as if the current business-oriented model was used for the merge. According to certain example embodiments, the connecting may be deterministic, e.g., such that the result will be the same regardless of order or sequence in which the propagations are made. | 04-25-2013 |
20130111430 | PROVIDING GOODS OR SERVICES | 05-02-2013 |
20130111431 | VALIDATION OF A SYSTEM MODEL INCLUDING AN ACTIVITY DIAGRAM | 05-02-2013 |
20130111432 | VALIDATION OF A SYSTEM MODEL INCLUDING AN ACTIVITY DIAGRAM | 05-02-2013 |
20130117726 | METHODS FOR TYPE ANALYSIS IN SYSTEMS FOR CODE GENERATION - A method for identifying a structure of a type to generate a model of the type includes the step of providing at least one replacement type for a basic type provided by a programming language. An identification of initialization, by a constructor, of an instance of the at least one replacement type is received. A type model comprising a description of a data layout of the instance of the type is generated responsive to the received identification. | 05-09-2013 |
20130117727 | ANALYTICAL SOFTWARE DESIGN SYSTEM - An analytical software design system arranged to receive informal system design specifications and to convert them into verified design specifications for use in creating source code and carrying out implementation testing of the source code is described. The system comprises a verified black box specification generator arranged to process the received informal system design specifications to create formal specifications; to generate from the formal specifications mathematical models representing the system behaviour; to analyse the mathematical models to determine if they have the required behaviour; to adjust the formal specifications until the required behaviour is achieved; and to derive the required verified design specifications from the mathematical models. | 05-09-2013 |
20130125086 | SOFTWARE ARCHITECTURE BY UNTANGLING UNDESIRED CODE LEVEL DEPENDENCIES USING CODE REFACTORING - A method of improving software architecture by untangling undesired code level dependencies is provided herein. The method includes the following stages: generating an abstract representation of a computer code in a form of a code model; recording manipulations to the computer code applied by a user to the code model; calculating a series of refactorings in the computer code that represents the recorded manipulation; and carrying out the refactorings within the computer code. Specifically, some of the refactorings include separating low level software elements on the method level in response to the user manipulations of the model. | 05-16-2013 |
20130125087 | Method For Estimating Resource Consumption In The Generation Of A Control Device Program Code - A method for estimating a resource consumption of storage space and/or of required runtime of a control device program code to be generated for a control program, whereby the functionality of the control program is given in an executable model. The model has a function with first functional magnitudes and first information associated with the first functional magnitudes and optimization parameters for optimizing a code generator. A program code representation is generated for part of the model comprising the function by the code generator taking into account first values of the optimization parameters. An estimation unit comprises a resource model with hardware parameters. An estimated value for the storage space requirement is determined for the control device program code and/or a runtime estimated value is determined for the control device program code by the estimation unit taking into account the hardware parameters and based on the program code representation. | 05-16-2013 |
20130139125 | METHOD AND SYSTEM FOR DATA MODELING ACCORDING TO OBJECT PERSPECTIVES - Techniques for the design and use of a perception modeling language for communicating according to the perspective of at least two communicators. The disclosed method and system provide for forming a model including a predetermined number of states and a plurality of related transitions. The disclosed subject matter represents each of said predetermined number of states according to a plurality of perspectives, said perspectives including a plurality of states and a set of related transitions, and forms a perspective language by deriving a plurality of functions associating said plurality of perspectives for representing at least one actually observable system. Furthermore, the perspective modeling language derives a set of modeling perspectives for modeling said at least one actually observable system. | 05-30-2013 |
20130159962 | IDENTIFYING APPLICATION RESOURCES THROUGH IMPLICIT APPLICATION MODELS - Determining a discrete application boundary. A method includes identifying one or more initial components of an application. The method further includes identifying statically and/or dynamically related components of the one or more initial components of the application. Identifying statically related components and identifying dynamically related components is performed iteratively. The method further includes identifying a discrete boundary for the application based on statically related components and dynamically related components. | 06-20-2013 |
20130159963 | Agile Unit and Regression Testing Framework for Domain Specific Languages - According to one aspect of the invention, a system and method for unit and regression testing has been developed. The system is capable to automate unit/regression test case preparation, remote execution, provide XML based assert mechanism to evaluate test results, maintenance and versioning. The present system enables model driven testing of domain specific languages and provides a user friendly mechanism to perform Unit and Regression Testing. | 06-20-2013 |
20130174116 | SYSTEMS AND METHODS FOR METAMODEL TRANSFORMATION - Some aspects relate to systems to determine a first metamodel conforming to a first meta-metamodel supporting metamodel class inheritance at the first metamodel level, identify one or more segments of an aggregation-free tree of nodes of the first metamodel, identify a lowest-level node of one of the one or more segments, identify all higher-level nodes of the one of the one or more segments, and consolidate attributes of each of the identified nodes of the one of the one or more segments into a node of a second metamodel conforming to a second meta-metamodel. | 07-04-2013 |
20130179857 | Multiple Architecture Viewpoints In Single Unified Modeling Language (UML) Model - A method, a system and a program product provide for defining for an information technology (IT) system that may be modeled within the context of a plurality of architecture viewpoints, and whose model elements are defined within a configuration file, a plurality of architecture viewpoints within a single UML model. The method, the system and the program product also provide for synchronously automatically updating a remainder of the architecture viewpoints when one of the architecture viewpoints is manually updated. | 07-11-2013 |
20130185694 | DECLARATIVE DYNAMIC CONTROL FLOW IN CONTINUATION-BASED RUNTIME - Techniques are described herein that are capable of executing a computer program in accordance with a declarative dynamic control flow in a continuation-based runtime. A declarative dynamic control flow identifies a set of continuations. A representation of logic that corresponds to the declarative dynamic control flow is provided in accordance with execution of the computer program in the continuation-based runtime. The declarative dynamic control flow identifies a set of continuations. Each continuation identifies a respective rule, which defines a respective event, and a respective action, which is to be performed upon occurrence of the respective event. A determination is made that a specified event occurs. The set of continuations is dynamically modified based on occurrence of the specified event. | 07-18-2013 |
20130219354 | SYSTEMS AND METHODS FOR GENERATING HIGH-QUALITY FORMAL EXECUTABLE SOFTWARE FEATURE REQUIREMENTS - Systems and methods for generating formal software requirements using an informal requirements document having informal requirements and annotations associated with the informal requirements. The systems and methods extract syntax from the annotations and generate artifacts as a function of the syntax. | 08-22-2013 |
20130227518 | Software Modeling System and Method - A device for modeling a software application includes an environmental model that includes a first set of attributes. The first set of attributes includes a value attribute, a declaration, and a set of meta-attributes. A behavioral model includes a second set of attributes, including a portion of the first set of attributes, wherein the environmental and behavioral models share the portion. The second set of attributes includes a value attribute and set of meta-attributes, each having at least one of a declaration and function. Changes to an attribute in the behavioral model reflect in all models that share the attribute. A design model includes a first decomposition of the second set of attributes into a first plurality of groups. A run-time model includes a second decomposition of the second set of attributes into a second plurality of groups, and records the decomposition of the behavioral model into run-time components. | 08-29-2013 |
20130232464 | DEPLOYMENT OF BUSINESS PROCESSES IN SERVICE-ORIENTED ARCHITECTURE ENVIRONMENTS - A computer-implemented business process deployment system and method are disclosed. The system includes memory which stores a design tool which receives a business process description and generates a deployment package composite based thereon. The business process description includes a set of business process activities for a business process, each of the business process activities in the set depending on abstract services for implementing the business process activity. An abstract bindings repository stores mappings between the abstract services and corresponding real services employed by an associated real service employing system. The deployment package composite is configured to bind the abstract service dependencies to the real services in the abstract bindings repository to generate a deployable business process composite that is deployable in the associated real service employing system. A processor implements the design tool. | 09-05-2013 |
20130232465 | TRANSACTION LEVEL MODEL SYNTHESIS - Converting from transaction level model to register transfer level. A method comprises accessing a transaction level model description. Function calls in the transaction level model description are automatically converted to signal accesses in a register transfer level description. Interface logic is automatically generated in the register transfer level description. The interface logic provides an interface between a bus interface and the signal accesses. The register transfer level description is stored in a computer readable medium. | 09-05-2013 |
20130246995 | SYSTEMS, METHODS, AND APPARATUS FOR MODEL-BASED SECURITY CONTROL - An integrated model-driven application development and execution environment enables declaration of a data-role in an application model. The data-role is based on a property of a data entity in the application model. The data-role provides for the enforcement of domain-specific security policies with respect to data elements corresponding to the data entity. | 09-19-2013 |
20130246996 | Declarative Software Application Meta-Model and System for Self-Modification - A solution providing for the dynamic design, use, and modification of models using a declarative software application meta-model that provides for self-modification of a collection of the models is provided. The solution can enable continuous real-time testing, simulation, deployment, and modification of the collection of the models. A model in the collection of the models can represent an entity or a function and can be included in a set of related models. Additionally, a set of related models can include a plurality of sets of related models. The collection of the models can represent, for example, one or more software applications, processes, and/or the like. | 09-19-2013 |
20130263080 | AUTOMATED BLUEPRINT ASSEMBLY FOR ASSEMBLING AN APPLICATION - The embodiments provide a data processing apparatus for automated blueprint assembly. The data processing apparatus includes a micro-blueprint assembler configured to receive a request for automated blueprint assembly for assembling an application, where the request specifies at least one feature, and a model database configured to store model data. The model data includes a plurality of classes and class properties. The data processing apparatus further includes a micro-blueprint database configured to store a plurality of micro-blueprints. Each micro-blueprint corresponds to a functional component of a stack element or service tier, and the functional component is annotated with one or more classes of the plurality of classes and at least one required capability and available capability. The micro-blueprint assembler is configured to generate at least one application blueprint based on the model data and the plurality of micro-blueprints according to the request. | 10-03-2013 |
20130263081 | MODEL EDITING ASSISTANCE DEVICE, MODEL EDITING ASSISTANCE METHOD, AND MODEL EDITING ASSISTANCE PROGRAM - There are provided repetitively referenced class determining means for determining whether or not there are similar elements which are elements referring to the same class and having different attributes or attribute values in an input model description; common class attribute extracting means for extracting an attribute shared by the similar elements extracted in accordance with a result of the determination as a common class attribute of a group comprising the similar elements; derived class generating means for generating derived classes inheriting the common class attribute and associating the derived classes with their respective extracted similar elements; attribute value determining means for setting concrete attribute values of the generated derived classes at values which are described as attribute values of the corresponding similar elements; and referenced class replacing means for replacing the class referred to by the extracted similar elements with the derived classes, the concrete attribute values of which have been set. | 10-03-2013 |
20130283228 | SOA-based Integration Method and System for 3D Design System - The present invention provides an SOA-based integration method for a 3D design system. The method comprises the following steps: 1) constructing an SOA integration development system platform, comprising four structural layers connected to each other, communicating with each other, and being, from top to bottom, an application layer, a business layer, a service layer, and a resource layer; 2) setting at least one global model data server at the resource layer, and setting a design information integration platform at the business layer; 3) setting multiple pieces of third-party 3D model design system software at the resource layer, encapsulating them into a WEB service through an API program thereof, and setting the WEB service at the service layer; 4) setting database systems of the multiple pieces of third-party 3D model design system software at the resource layer, connecting the database systems to the global model data server through a data bus for mutual communication; and 5) setting an integration web portal at the application layer, wherein the portal is integrated with sign-in links of the third-party 3D model design system software. The present invention further provides a system for implementing the above method. | 10-24-2013 |
20130290923 | Systems and Methods for Generating a Standardized Power Generation Class Model - Certain embodiments herein relate to generating a power generation class model for use by program code to interact with one or more operational components in a power generation system. The class model may include objects and elements which may be associated with operational components and attributes associated with the operational components, respectively. Associations may be made between such operational components and their attributes. Various representations of the class model, based at least in part on the associations, may be output for use by program code. In one embodiment, a class model may be generated using Uniform Modeling Language (UML). The UML class may be converted to a schema, such as Extensible Markup Language Schema Definition (XSD), and compiled to create a Java or C# object, in one embodiment. | 10-31-2013 |
20130305213 | MODULARIZED CUSTOMIZATION OF A MODEL IN A MODEL DRIVEN DEVELOPMENT ENVIRONMENT - A method for the modularized customization of a model within a model driven development environment includes selecting a template specifying a base model and different points of variability of a base model in a model driven development environment and transmitting over a data communications network an electronic form configured to receive data in different data fields representative of the points of variability. Thereafter, a submission of the electronic form can be received and data from the received submission representative of the points of variability can be extracted. Instructions can be added to a control file corresponding to the points of variability and the control file can be processed to generate artifacts in an import file specifying the points of variability. Finally, the import file can be imported into the model driven development environment and the base model modified with the points of variability of the artifacts. | 11-14-2013 |
20130318492 | MECHANISM FOR FACILITATING DYNAMIC INTERACTION WITH DEVELOPMENT APPLICATIONS AND TOOLS AN ON-DEMAND SERVICES ENVIROMENT - In accordance with embodiments, there are provided mechanisms and methods for facilitating dynamic interaction with development applications and tools in an on-demand services environment in a multi-tenant environment according to one embodiment. In one embodiment and by way of example, a method includes receiving, from log files, historical user preferences and usage data relating to a user and one or more development tools for software development at a computing device. The historical user preferences and usage data may be based on past acts of the user and recorded at the log files. The method may further include generating a model based on the historical user preference and usage data, determining one or more predictions from the model. The predictions may include one or more of: an ordering of the development tools, a filtering of a plurality of features of one or more of the development tools, and a usage-based customization of the one or more development tools. The method may further include providing the development tools for display to the user based on the predictions. | 11-28-2013 |
20130318493 | Model Elements in Software Tools as Automatons in a Software Customization System and Method - Presented is a system and method for the integration of existing software development tools into a software customization system, where each software development tool has its own model of its software artifacts. The invention allows models in an external software development tool to become software artifacts within a software customization system, and also allows the model elements of the existing tools to become automatons. | 11-28-2013 |
20130326470 | DOMAIN-SPECIFIC GENERATION OF PROGRAMMING INTERFACES FOR BUSINESS OBJECTS - A code generator may determine an object metadata model which defines structures and behaviors of objects adapted for use in at least one software application, where the code generator includes an object analyzer configured to determine at least one object instance of the object metadata model, a domain analyzer configured to determine a domain associated with the at least one object instance, and a template selector configured to select a domain-specific code template based on the domain. The code generator may generate a domain-specific application program interface (API) configured to facilitate interactions of the at least one object instance during execution of the at least one software application, using the domain-specific code template. | 12-05-2013 |
20130332897 | CREATING A USER MODEL USING COMPONENT BASED APPROACH - A computerized method of creating a user model, comprising:
| 12-12-2013 |
20130339923 | Data Handling Among Actors in a Dataflow Programming Environment - Processing a dataflow program by a program development tool includes detecting a pair of actors defined by dataflow program instructions, wherein the pair of actors include a producer actor and a consumer actor, the producer actor supplying a data structure to the consumer actor via a path that comprises at least one connection and possibly also intervening other actors. An analysis is performed including analyzing one or more operations of the producer actor that involve the data structure and/or analyzing one or more operations of the consumer actor that involve the data structure. A result of the analysis is used as a basis for selecting a minimal amount of information from among a plurality of data handling possibilities concerning the data structure. A transformed program is produced in which the selected minimal amount of information is caused to be passed from the producer actor to the consumer actor. | 12-19-2013 |
20130339924 | GATEWAY DATA DISTRIBUTION ENGINE - Implementations include a method, system, and apparatus for receiving, from a user communicably connected to a network, a selection of one or more gateway service data categories; receiving, from the user, a selection of an operating platform of a mobile device operable to be communicably connected to the network; generating a configuration file comprising a selection of gateway service data associated with one or more gateway service data categories and the operating platform selection; generating a data store file and a development library associated with the operating platform selection; transferring the configuration file, the data store file, and the development library to a repository communicably connected to the network; and generating an application template comprising the configuration file, the data store file, and the development library, wherein the mobile application is developed on the mobile device from the application template while the mobile device is communicably disconnected from the network. | 12-19-2013 |
20130346939 | Methods and Systems Utilizing Behavioral Data Models With Views - Embodiments include computer systems, methods, and program code for developing and utilizing data models. The model can comprise a property and a view for the modeled component, the property defining a data element of the modeled component and the view defining an interface element for receiving or providing data represented by the property. The model may comprise a behavior in addition to the view, with the behavior comprising a programmatic expression of an operation to be performed when the model is consumed, such as a function for determining when the variably applicable portion of the model is to be used based on a condition. Consuming the model can comprise generating an in-memory representation of the modeled component, the in-memory representation comprising a data structure corresponding to the property and code for providing an interface element configured to receive input or provide output of data maintained in the data structure. | 12-26-2013 |
20140007039 | DISCOVERY AND MODELING OF DEPLOYMENT ACTIONS FOR MULTIPLE DEPLOYMENT ENGINE PROVIDERS | 01-02-2014 |
20140007040 | Service model-oriented software operation platform and operation method thereof | 01-02-2014 |
20140019934 | GENERATION FRAMEWORK FOR MAPPING OF OBJECT MODELS IN A DEVELOPMENT ENVIRONMENT - A delta handler can allow calculation of difference between an already generated set of backend entities and a set of new entities necessary to support a primary object affected by a change made in a development environment supporting extensions to a backend model of a software architecture. Improved stability and robustness can be provided via an approach in which a target list of activities relating to creating, changing, or deleting of entities in backend repositories necessary to support the affected primary object is created and a sequence for performance of the activities in the target list is determined in a manner that can allow handling of such activities in a unified manner rather than on a per object type basis. Related methods, systems, articles of manufacture, and the like are described. | 01-16-2014 |
20140033167 | METHOD AND SYSTEM FOR GENERATING A MANIFESTATION OF A MODEL IN ACTIONSCRIPT - Computer-based methods and systems for generating script-based code, based on a model, are described. Consistent with an embodiment of the invention, a software development application includes a code generator module that receives a model. The code generator module processes the model to generate script-based code. Specifically, the script-based code includes a value object class for each model entity defined in the model, and a service wrapper object class for each service element defined in the model. The value object classes support both basic and advanced data modeling capabilities and corresponding data operations. The service wrapper object classes provide a remote service capability, enabling the client application to communicate with remote services implemented on an application server. | 01-30-2014 |
20140033168 | METHOD AND SYSTEM FOR PROVIDING MODELED COMPONENTS - A system for providing modeled components is described. An example system comprises a request detector, an entity component, a style component, and a property module. The request detector may be configured to receive requests to create modeled components. The entity builder may be configured to create entities associated with models. The styles designer may be configured to create style components. A style component defines a user interface to be applied to a property of an entity in a modeled component. The property module may be configured to associate a style component with one or more properties of one or more entities. | 01-30-2014 |
20140033169 | METHOD AND SYSTEM FOR PROVIDING SERVICES IN MODELED COMPONENTS - A system for providing one or more services in modeled components is described. An example system comprises a request detector, an entity component, and a service component. The request detector may be configured to receive requests to create modeled components. The entity builder may be configured to create entities associated with models. The services designer may be configured to create service components. A service component includes one or more functions that can be called from a property of an entity in the modeled component. | 01-30-2014 |
20140047406 | Path driven programming method and programming tool - A cloud servicing system is provided to support a consumer for interactively programming a programmable product such as programmable toys or home security system. A consumer friendly path driven programming method is introduced to supplement the servicing cloud and support the new world of intelligent home and consumer programmable applications. The system may comprise a consumer programmed smart phone/touch pad as well as proprietary smart phone circuit. | 02-13-2014 |
20140047407 | SYSTEMS AND METHODS FOR CREATING APPLICATION INTERFACES FOR FORMING AND SOLVING PROBLEMS IN A MODELING SYSTEM - An apparatus for generating an application data structure includes a physical computing system comprising processor(s), input device(s), display(s), and memor(ies). The memory includes executable instructions that cause a processor to perform the acts of embedding a multiphysics model data structure for a physical system in an application data structure. Application features are determined to add to the application data structure. First data is added representing a form feature for the application features for the model of the physical system. Second data is added representing at an action feature for the application features. The second data is associated with at least one modeling operation to define a sequence of operations for modeling the physical system. The application data structure is updated including the added first and second data and the associating defining the sequence of operations. The updated application data structure is stored on the memory device(s). | 02-13-2014 |
20140047408 | System Integrator And Method For Mapping Dynamic COBOL Constructs To Object Instances For The Automatic Integration To Object-Oriented Computing Systems - A system integrator for modeling an object instance of a COBOL data set, the object instance including representations of OCCURS DEPENDING ON clauses or REDEFINE clauses. The system comprises a client interface module, an import module, an object model module and modeler module. The client interface module generates an interface and receives a copybook selection and a set of REDEFINE criteria. The import module receives the copybook selection and imports a copybook from a database. The object model module receives the copybook and the set of REDEFINE criteria, and creates a customized object model for the copybook. The modeler module receives the customized object model and a set of COBOL data, and forms an object instance equivalent to the set of COBOL data, the object instance including representations of a OCCURS DEPENDING ON clause or REDEFINE clause. | 02-13-2014 |
20140059514 | Methods and Systems Utilizing Behavioral Data Models - Embodiments include computer systems, methods, and program code for developing and utilizing behavioral data models. A model can comprise a property and a behavior of the modeled component, with the property defining a data element of the modeled component and the behavior comprising a programmatic expression defining an operation to be performed when the model is consumed. Consuming the model can comprise generating an in-memory representation of the modeled component. The in-memory representation can comprise a data structure corresponding to the property and a functional component comprising code configured to implement the behavior. The in-memory representation is used directly in the operation of the computer application to process data, such as by storing or retrieving data from the data structure and/or by executing the code that implements the behavior. In some embodiments, consuming the model comprises outputting a program component, such as source or object code, based on the in-memory representation. | 02-27-2014 |
20140059515 | COMMUNICATION VIRTUAL MACHINE - A system for automating at least a portion of a communication application development cycle using a communication virtual machine that automatically interfaces with an existing network system and provides an engine for executing designed application models over the existing network system. | 02-27-2014 |
20140068546 | Automated Deployment of a Configured System into a Computing Environment - Automatically deploying a configured system into a computing environment (such as a cloud computing environment) for execution therein comprises obtaining a configured architecture model describing the configured system, and iteratively evaluating the model to deploy pre-built components for the system and to create and enable a development environment in the computing environment for development of custom-built components needed for the system according to the model. The automated deployment processing further comprises automatically configuring the system; determining a proper installation sequence; allocating resources in the target environment; and installing the required tools and other software that will be needed for execution once the components of the system are deployed. Component metadata is used during the deployment, enabling automated consideration of various factors such as whether component dependencies, resource requirements, and compatibility issues are met. | 03-06-2014 |
20140068547 | SHARING APPLICATION CODE ACROSS PLATFORMS - Application functionality is separated into platform neutral components and platform specific components. An application model component defines the core logic of the application and includes interaction models for handling user input that is platform neutral and may be used across platforms. An application host component includes functionality for a specific platform but may be reused across different applications on the same platform (e.g. how to draw on a specific platform). An application user interface component includes functionality (e.g. specific UI for an application) that is platform specific and application specific. Platform neutral Application Programming Interfaces (APIs) are used by the developer to abstract functionality of the application such that the platform neutral code is portable across different platforms. The communication between the platform specific components and platform neutral components uses thread and memory isolation similar to a client-server architecture. | 03-06-2014 |
20140068548 | PARAMETER SETTING APPARATUS AND METHOD FOR AUTOMOTIVE OPEN SYSTEM ARCHITECTURE-BASED SOFTWARE - The present invention discloses a parameter setting apparatus and method for AUTOSAR-based software, which may lead a user to set parameters at suitable times depending on the variant attributes of parameters. In the parameter setting method, a selection of a variant attribute of a parameter of a metamodel defined to design AUTOSAR-based software is received from a user. If the variant attribute selected by the user corresponds to a variant-pre-compile attribute, setting of only a parameter having the variant-pre-compile attribute is allowed. If the variant attribute selected by the user corresponds to a variant-link attribute, setting of only a parameter having either one of the variant-pre-compile attribute and the variant-link attribute is allowed. If the variant attribute selected by the user corresponds to a variant-post-build attribute, setting of only a parameter having any one of the variant-pre-compile attribute, the variant-link attribute, and the variant-post-build attribute is allowed. | 03-06-2014 |
20140068549 | METHOD AND SYSTEM FOR PROVIDING CONTENT - A computer-implemented method for generating one or more applications, the method including the steps of: accessing a template for holding content; populating the template with the content; generating the one or more applications, configured for a plurality of computing platforms, based on the populated template; and making the applications available for distribution by a server. | 03-06-2014 |
20140075408 | System and Method for Generating High Performance Calculators for Calculation Graphs - Systems and methods for generating customized calculation execution graphs for producing analysis and reports from large stores of data are disclosed. The customized calculation execution graphs are instantiated from user supplied calculation definition tables and calculation input definition tables. The calculation definition tables and the calculation input definition tables are instantiated to produce a calculation graph model. The calculation definitions of the calculation graph model can be sorted based on the number of intermediate calculations required as input for each one of the defined calculation. The sorting calculation graph model can then be instantiated to generate the calculation execution graph. Such calculation execution graphs include a number of ordered calculation nodes with pairwise connections indicating the order of operations and data flow. The calculation execution graph can then be instantiated into a platform specific application programming language to run on a variety of server and client computers. | 03-13-2014 |
20140082584 | METHOD AND SYSTEM FOR DEVELOPMENT OF APPLICATION PROGRAM - Provided is a method and system for developing an application program efficiently. The method may include modeling an application program based on a development goal of the application program, and decomposing the modeled application program into sub-application programs, and modeling the sub-application programs. | 03-20-2014 |
20140082585 | METHOD OF CREATING A SOFTWARE APPLICATION, THE METHOD BEING PERFORMED BY AN ENGINE - This disclosure includes a method performed by a generic engine for dynamically creating a software application suitable for satisfying an initial objective. The engine may interrogate a knowledge base including a computer object including an interpretable module together with a description of a result obtained on interpreting said module. Various implementations include sending a request to the knowledge base that includes a “current” objective; obtaining results, which may be partial, by interpreting a module of a computer object received in response to the request; compiling the obtained partial results to determine whether they enable a “final” result to be formed that satisfies the initial objective; if so, sending the final result in response to the initial objective; if not, defining a new current objective from at least one of said results, said complied partial result and possibly current objectives defined during preceding iterations, and executing another iteration. | 03-20-2014 |
20140082586 | APPLICATION DEVELOPMENT SYSTEM AND METHOD FOR OBJECT MODELS AND DATAGRAPHS IN CLIENT-SIDE AND SERVER-SIDE APPLICATIONS - An application development system and method are provided for object models and datagraphs in client-side and server-side applications of a web-based or cloud-based application deployment platform. The system and method are used for representing, persisting, permitting, traversing, querying, manipulating and extending object models and their imputed datagraphs, in applications spanning the client-side and server-side of the web-based or the cloud-based application deployment platform. | 03-20-2014 |
20140089888 | Modernization Of Legacy Software Systems Based On Modeled Dependencies - Methods, systems, and computer-readable media are described herein for migrating a non-object-oriented application to an object-oriented platform. The non-object-oriented application may be received. The non-object-oriented application may be parsed into elements of the non-object-oriented application. A design structure matrix (DSM) representation of the elements may be generated. A final object model may be generated based on the DSM representation. The final object model may be mapped to a code skeleton representation of an object-oriented development environment. | 03-27-2014 |
20140089889 | BEHAVIOR INVARIANT OPTIMIZATION OF MAXIMUM EXECUTION TIMES FOR MODEL SIMULATION - A device receives a model that includes model elements scheduled to execute in time slots on a hardware device. The device identifies time slots, of the time slots, that are unoccupied or underutilized by the model elements, and identifies a set of model elements that can be moved to the unoccupied time slots without affecting a behavior of the model. The device calculates a combined execution time of the model elements, determines whether the combined execution time of the model elements is less than or equal to a duration of a first time slot of the time slots, and schedules the model elements for execution in the first time slot when the combined execution time of the model elements is less than or equal to the duration of the first time slot. | 03-27-2014 |
20140109036 | Systems and Methods for Mining Temporal Requirements from Block Diagram Models of Control Systems - Systems and methods for mining a temporal requirement from a block diagram model of a closed loop control system are disclosed. One embodiment of a method includes simulating the closed loop control system of a vehicle to obtain simulation traces and determining a candidate requirement by instantiating a template requirement with values of the simulation traces to locate parameter values that suggest that the template requirement is fulfilled. Some embodiments of the method include determining whether a counterexample to the candidate requirement exists; and in response to determining that the counterexample to the candidate requirement exists, obtaining the counterexample to the candidate requirement and adding the counterexample to the simulation traces for inspection. | 04-17-2014 |
20140115558 | Generating and Employing Operational Abstractions of Transforms - Methods and arrangements for employing a software model transform. A software model transform is accepted, and the transform is manipulated to obtain a transform representation. At least one functional path is explored with respect to the transform representation. A trace is conducted of at least one explored path, and an abstraction of the transform is produced via utilizing the trace, the abstraction comprising a simplified semantic view of the transform. | 04-24-2014 |
20140130006 | APPARATUS AND METHOD OF GENERATING MULTI-LEVEL TEST CASE FROM UNIFIED MODELING LANGUAGE SEQUENCE DIAGRAM BASED ON MULTIPLE CONDITION CONTROL FLOW GRAPH - Disclosed herein are an apparatus and a method for generating a multi-level test case for testing software from a unified modeling language (UML) sequence diagram (SD) based on a multiple condition control flow graph (MCCFG). The apparatus includes: a UML SD metamodel storing unit storing a UML SD metamodel defined for a model to be converted therein; an MCCFG metamodel storing unit storing an MCCFG metamodel; a model converting unit model-converting the UML SD from which the test case is to be generated according to the UML SD metamodel and the MCCFG metamodel to generate the MCCFG; and a coverage criteria unit converting the MCCFG into a tree structure and then converting the tree structure into test cases according to a selection command. | 05-08-2014 |
20140130007 | METHODS AND TOOLS FOR DATA-DRIVEN APPLICATION ENGINEERING - The invention generally relates to enterprise computer applications, and more particularly to methods and tools for data-driven engineering of computer applications. A method of generating a business application includes inputting requirement data into a requirement model, inputting platform data into a platform model, generating a design model based on the requirement model and the platform model, generating source code of the business application from the design model, and outputting the source code. | 05-08-2014 |
20140143751 | Methods and Arrangements for Processing and Presentation of Information - An embodiment may correspond to a computing platform that supports a new computing paradigm, called the resolution-centered paradigm, also referred to as a definition-centered paradigm. | 05-22-2014 |
20140173550 | Computer-Implemented Systems and Methods for Automated Generation of a Customized Software Product - Systems and methods are provided for automated generation of a customized software product. A system includes a computer-readable medium encoded with a project parameters data structure, where the project parameters data structure includes a plurality of project requirement records, and a project prototype. One or more data processors are configured to process a plurality of initial characteristics for the customized software product, populate the project parameters data structure at least based on the initial characteristics, and generate the project prototype based on the project parameters data structure. The one or more data processors are further configured to output a requirements matrix data structure at least based on the project parameters data structure and the project prototype and to generate the customized software product at least based on the requirements matrix data structure and the project prototype. | 06-19-2014 |
20140181783 | COMPONENT INTEGRATION BY DISTRIBUTION OF SCHEMA DEFINITION ON HETEROGENOUS PLATFORMS - According to some embodiments, a method and system including a first technology stack to receive a model description describing defining aspects of an application model; to generate, according to the model description, a model entity representation of the application model; and to transfer the model description to a second technology stack; and a second technology stack to generate, according to the model description, a model entity representation of the application model. | 06-26-2014 |
20140181784 | DYNAMIC USER INTERFACE TAG FORMAT - A system and method for facilitating characterizing data to enable dynamic generation of a user interface feature based on the data. An example method includes maintaining data in accordance with a data model accessible to webpage computer code, wherein the data model is adapted to be populated with data associated with one or more data attributes in the data model; and providing a signal, identifying a data attribute, from the data model to webpage computer code to facilitate dynamic construction of one or more user interface features characterizing a rendering of a webpage. Data in the data model is characterized by one or more data attributes, each of which is associated with an attribute definition. The example method may further include organizing one or more attribute definitions in the data model as computing objects containing characterizations of the one or more data attributes. | 06-26-2014 |
20140189636 | MIGRATION BETWEEN MODEL ELEMENTS OF DIFFERENT TYPES IN A MODELING ENVIRONMENT - Migration between model elements of different model element types in a model provided within a modeling environment is described herein. A model element of a first model element type is identified to be migrated to a model element of a second model element type. The model element of the first model element type is then migrated to the model element of the second model element type. The migrating migrates one or more relationships that exist between the model element of the first model element type and a related model element to one or more relationships between the model element of the second model element type and the related model element. The migrating also preserves properties of diagrammatic representations of the model element being migrated in diagrams of the model. | 07-03-2014 |
20140196001 | SOFTWARE DEVELOPMENT METHODOLOGY SYSTEM FOR IMPLEMENTING BUSINESS PROCESSES - A software development tool for developing software that implements a customer's business processes. The software development tool determines a plurality of models to define the software to be developed, wherein at least one model of the plurality of models is a business model that comprises at least one business process, and the at least one business process is a set of interrelated business process paths that accomplish a business goal. The software development tool defines at least one business process path, wherein the at least one business process path is a route through the at least one business process taken during a single execution of the at least one business process, and the at least one business process path comprises at least one step. The software development tool maps the defined at least one business process path to a second model different than the business model, wherein the mapping identifies at least one part of the second model that implements the at least one step of the business process path. The software development tool builds the at least one business process path based on results of the mapping. The software development tool delivers the at least one business process path that has been built. | 07-10-2014 |
20140196002 | TOOL AND METHOD THEREOF FOR EFFICIENT DESIGN OF INFORMATION TECHNOLOGY SYSTEMS - A design tool and method for designing information technology (IT) systems are provided. The method includes receiving at least one requirement for the IT system; receiving a layout of the IT system; extracting the at least one requirement and the layout; classifying the at least one requirement; selecting a design pattern respective of each of the at least one classified requirement and the layout; linking each of the at least one classified requirement to at least one design dimension; producing an at least one complete design of the IT system; and querying a user to determine whether the at least one complete design of the IT system has been approved by the user. | 07-10-2014 |
20140201706 | CREATING PLUGGABLE ANALYSIS VIEWPOINTS FOR AN OPTIMIZATION SYSTEM MODEL - A method of creating a system having pluggable analysis viewpoints over a design space model based on templates for analytical representation of different system aspects, comprising:
| 07-17-2014 |
20140215430 | METHOD AND APPARATUS FOR ENABLING LAYERED PROPERTY DEFINITION IN TRADITIONAL AND CLOUD COMPUTING ENVIRONMENTS - In developing custom programming, particularly for clients or tenants of a cloud computing environment, following pointers from a candidate, existing object of interest vertically to obtain inherited attributes and horizontally to obtain encapsulated properties and presenting such attributes and properties to a software developer for editing and inclusion in custom object-oriented programming facilitates and expedites accommodation of requirements of model based design for potential or existing tenants or clients of a cloud computing environment. | 07-31-2014 |
20140215431 | STATIC ANALYSIS OF COMPUTER SOFTWARE APPLICATIONS HAVING A MODEL-VIEW-CONTROLLER ARCHITECTURE - Preparing a computer software application for static analysis by identifying a control flow within a model portion of a computer software application having a model-view-controller architecture, where the control flow passes a value to a controller portion of the computer software application, analyzing a declarative specification of the controller portion of the computer software application to identify a view to which the controller portion passes control based on the value, and synthesizing a method within the computer software application, where the method calls the view. | 07-31-2014 |
20140223410 | APPLICATION ARCHITECTURE DESIGN METHOD, APPLICATION ARCHITECTURE DESIGN SYSTEM, AND RECORDING MEDIUM - Provided is an application architecture design method in which an information processing device is used, the method including the steps of: inputting information about dependency relations and design aspects, which are design items regarding modules for running functions, virtual machines for running the modules, and physical machines for running the virtual machines; and executing processing of adapting architecture properly by switching the input information about the dependency relations and the design aspects in matrices in a DSM format, and thereby rearranging allocation of the modules, allocation of the virtual machines, and allocation of the physical machines in stages in the DSM format. As a result, an excellent design solution for architecture suitable for a virtualized environment, a cloud environment deriving, or a similar environment can be derived. | 08-07-2014 |
20140245254 | IDENTIFYING QUALITY REQUIREMENTS OF A SOFTWARE PRODUCT - A method(s) and system(s) of identifying quality requirements for a software product to be developed is disclosed. The method includes receiving input data from a user. The input data is indicative of objectives to be met by the software product being developed. The method further includes mapping the input data with a pre-defined product quality requirement model (PQRM). The PQRM is retrieved from a database and includes a taxonomy tree configured to define a plurality of quality characteristics (QCs), a plurality of sub-QCs, a plurality of quality objectives (QOs), and a plurality of quality requirements (QRs) for the software product. Further, the method includes identifying at least one QR from the plurality of QRs applicable for the software product. The identification is based on the input data. The method also includes generating a product requirement report (PRR) for the software product based on the identification. | 08-28-2014 |
20140282358 | Software Product Capable of Using Zero and Third Party Applications - A software product with an integrated application platform can provide functionality for modifying, adding, or removing features of a software product through the use of applications that are integrated into the software product. A software product with an integrated application platform can also provide for the ability of a third party to modify the features of a generic version of a software product to create a custom software product. The developer of the software product can identify features of the software product that are modifiable and/or extendable. When a user selects one or more features to be modified, the features to be modified can be checked against a feature list to see if the features are modifiable. If the features are modifiable, the software product can invoke a search mechanism to allow a user to search various sources for applications that are usable within the software product. | 09-18-2014 |
20140282359 | AUTOMATED SOFTWARE COMPOSITION - A method for automated composition of an application including: receiving a customizable template for application composition and a composition goal, wherein the goal comprises a plurality of tags and the goal is incomplete such that more than one possible composition matches the goal; refining the goal by automatically adding refinement tags to the goal; and generating an application flow that matches the customizable template and the refined goal, wherein the application flow comprises data sources, data processing operators, and outputs of the application flow. | 09-18-2014 |
20140282360 | METHOD AND SYSTEM FOR GENERATING A GLOBAL REPRESENTATION OF A PRODUCT DEFINITION - A method or system that receives a product definition that includes a feature family having data defining one or more product features. The product definition including one or more corresponding rules defining one or more relationships between one or more product features. The method or system receiving input selecting one or more feature families of interest. The method or system identifying the one or more rules that provide a relationship connecting the one or more feature families to the selected feature families of interest. The method or system converting the identified rules to one or more positive logic rule groups. The method or system generating one or more global representations of the product definition by interacting the one or more positive logic rule groups to produce a result that defines the relationship between the interacted positive logic rule groups and storing the results that are determined as being valid | 09-18-2014 |
20140282361 | METHOD AND SYSTEM FOR GENERATING A GLOBAL REPRESENTATION OF A PRODUCT DEFINITION - A method or system that receives a product definition that includes a feature family having data defining one or more product features. The product definition including one or more corresponding rules defining one or more relationships between one or more product features. The method or system receiving input selecting one or more feature families of interest. The method or system identifying the one or more rules that provide a relationship connecting the one or more feature families to the selected feature families of interest. The method or system converting the identified rules to one or more positive logic rule groups. The method or system generating one or more global representations of the product definition by interacting the one or more positive logic rule groups to produce a result that defines the relationship between the interacted positive logic rule groups and storing the results that are determined as being valid | 09-18-2014 |
20140282362 | METHOD OF TAKING A COMPUTER ARCHITECTURE RESPRESENTATION AND GENERATING MANUFACTURING METHODS CAPABLE OF MANUFACTURING A COMPUTER SYSTEMS CONTAINED IN A SPECIFICATION - Techniques and a system for creating a vendor independent computer language and compiling the language into an architecture specification language allowing for taking a source data stream (file, WSDL, XML) and passing thru a language parser, populating a storage medium with a plurality of technical inputs and vendor technical specifications for generic technologies and probable technologies required for desired architectures generated by the language parser, and optimizing the inputs and creating relationships between technologies and groups of technologies and storing results in the storage medium. | 09-18-2014 |
20140282363 | METHOD OF GENERATING A COMPUTER ARCHITECTURE REPRESENTATION IN A REUSABLE SYNTAX AND GRAMMAR - Techniques and a system for creating a vendor independent computer language and compiling the language into an architecture specification language allowing for taking a source data stream (file, wsdl, xml) and passing thru a language parser, populating a storage medium with a plurality of technical inputs and vendor technical specifications for generic technologies and probable technologies required for desired architectures generated by the language parser, and optimizing the inputs and creating relationships between technologies and groups of technologies and storing results in said storage medium. | 09-18-2014 |
20140289698 | Tool compiler - Automatic generation of documentation and software for an equipment or tool, together with an automatic synchronization between the corresponding documentation and software can be preformed with a tool model representation. The tool model can include a textual, graphical, symbolic, and program representation of the tool. Default components, derived components, and standard components can be added to the tool model. | 09-25-2014 |
20140310681 | ASSISTED CREATION OF CONTROL EVENT - The facilitated selection of an event that would trigger a control to perform a behavior. The control has multiple events that that may be used to trigger a behavior. It could perhaps be difficult for a user, especially a non-programmer, to select the appropriate event that triggers any given behavior. The system helps by automatically identifying a set of one or more events that are consistent with an intent for the control to perform a behavior of interest, in response to the user specifying the behavior. The automatically identified event might also depend on data of interest that the user identifies as to be operated upon by the control in performing the behavior. The system might propose one or more of the automatically identified events, and might even automatically configure the control to perform the behavior in response to a selected event. | 10-16-2014 |
20140310682 | DEVICE AND METHOD FOR GENERATING APPLICATION MODEL BASED ON LAYERED STRUCTURE - This disclosure presents an application model generation device and method based on hierarchy structure. A user may build an algorithm factor configuration instructions based on the actual application demands before implementing the application model, and update and/or modify one or more of the algorithm factors by means of the algorithm factor configuration instructions, and thus implementing flexible expansion for the application model. The application model generation device and method based on hierarchy structure as disclosed herein have flexible expandability, and the configuration efficiency is increased and the complexity in the configuration process is decreased duo to the implementation of the reusability of the algorithm factors, the meta-application algorithm units and the scenarios. | 10-16-2014 |
20140317593 | HIGHLY EXTENSIBLE REQUIREMENT ANALYSIS METHOD AND SYSTEM OF THE SAME - A highly extensible requirements analysis method and a system of the same are revealed. First collect user requirements of a software system and modify the user requirements by a breadth analysis tool and a depth analysis tool. Then generate actors that interact with the software system and collect more actors by the breadth analysis and depth analysis tools so as to make the actors with breadth and depth. Next generate use case diagrams of respective actor according to the above user requirements and the actors. Finally, the use case diagrams are modified by the breadth analysis and depth analysis tools so that the use case diagrams have breadth and depth. Thereby the user requirements of the software system are collected quickly and defined precisely at the requirements analysis and definition stages. The software development efficiency is improved and the cost is reduced. | 10-23-2014 |
20140351787 | Decision Service Manager - The disclosure generally describes computer-implemented methods, software, and systems for modeling and deploying decision services. One computer-implemented method includes creating a connection between a decision service manager and a managed system, establishing a signature of a decision service, developing, using at least one computer, the decision service based upon the established signature of the decision service, performing a deployment readiness check, transferring generated code implementing the decision service to the managed system upon a determination that the deployment readiness check was successful, inserting the generated code into the managed system, and retrieving a deployment status from the managed system. | 11-27-2014 |
20140359556 | UNIFIED DATACENTER STORAGE MODEL - Modeling an application deployed in a distributed system. The method includes accessing an infrastructure model of a distributed system. The infrastructure model includes a model of specific physical hardware including unique identifiers for each piece of hardware and an identification of interconnections of the physical hardware. The method further includes accessing an application model for an application. The application model defines the components that make up the application and how the components are to be deployed. The method further includes deploying the application in the distributed system by deploying elements of the application on hardware modeled in the infrastructure model. The method further includes using the infrastructure model and the application model deployment creating a deployment model defining how the application is deployed on the physical hardware. | 12-04-2014 |
20140365992 | BEHAVIOR INVARIANT OPTIMIZATION OF MAXIMUM EXECUTION TIMES FOR MODEL SIMULATION - A device receives a model that includes model elements scheduled to execute in time slots on a hardware device. The device identifies time slots, of the time slots, that are unoccupied or underutilized by the model elements, and identifies a set of model elements that can be moved to the unoccupied time slots without affecting a behavior of the model. The device calculates a combined execution time of the model elements, determines whether the combined execution time of the model elements is less than or equal to a duration of a first time slot of the time slots, and schedules the model elements for execution in the first time slot when the combined execution time of the model elements is less than or equal to the duration of the first time slot. | 12-11-2014 |
20140372967 | Formal Verification of Temporal Properties Expressed Using Local Variables - A certain subset of temporal properties defined using local variables can be formally verified with complexity of PSPACE or less. A subset with this characteristic, referred to as a practical subset, is therefore feasible to formally verify. For example, it can be shown that temporal properties that possess an alternating automaton with no conflicts fall within a practical subset. Temporal properties are analyzed to determine whether they are a member of the practical subset. Members of the practical subset can then be feasibly formally verified. | 12-18-2014 |
20140372968 | SOFTWARE MODELING FRAMEWORK - A system and method for providing a software modeling framework which supports different types of dependency injection and other software modeling or software development frameworks, and which allows software developers to develop models that strategically layer different components for different implementations. A service provider interface (SPI) enables different DI frameworks to be incorporated into the system; while an application provider interface (API) enable machines or implementations to be constructed. Extenders can be modeled so that, for example a particular bundle requires a handler for a particular configuration manifest entry; while a particular module provides handling of that manifest entry. | 12-18-2014 |
20140380266 | Parallel Programming of In Memory Database Utilizing Extensible Skeletons - An execution framework allows developers to write sequential computational logic, constrained for the runtime system to efficiently parallelize execution of custom business logic. The framework can be leveraged to overcome limitations in executing low level procedural code, by empowering the system runtime environment to parallelize this code. Embodiments employ algorithmic skeletons in the realm of optimizing/executing data flow graphs of database management systems. By providing an extensible set of algorithmic skeletons the developer of custom logic can select the skeleton appropriate for new custom logic, and then fill in the corresponding computation logic according to the structural template of the skeleton. The skeleton provides a set of constraints known to the execution environment, that can be leveraged by the optimizer and the execution environment to generate parallel optimized execution plans containing custom logic, without the developer having to explicitly describe parallelization of the logic. | 12-25-2014 |
20140380267 | LIFECYCLE MANAGEMENT SYSTEM WITH CONDITIONAL APPROVALS AND CORRESPONDING METHOD - Certain example embodiments concern a lifecycle management system for at least one computing component. A lifecycle model, including lifecycle states assignable to the at least one computing component, is defined. The lifecycle states include a production state. The lifecycle management system ensures the at least one computing component can be productively used only if it is assigned the production state. A lifecycle transition request assigning a requested target lifecycle state of the lifecycle model to the at least one computing component is received. A conditional lifecycle state, different from the requested target lifecycle state, is assigned to the at least one computing component. At least one condition to be fulfilled for the at least one computing component to be assigned the requested target lifecycle state is assigned. The requested target lifecycle state is automatically assigned to the at least one computing component when the at least one condition is fulfilled. | 12-25-2014 |
20140380268 | DYNAMICALLY EVOLVING COGNITIVE ARCHITECTURE SYSTEM PLANNING - Dynamically evolving cognitive architecture system planning is described. A system forms an intent based on a user input, and creates a plan based on the intent. The plan includes a first action object that transforms a first concept object associated with the intent into a second concept object and also includes a second action object that transforms the second concept object into a third concept object associated with a goal of the intent. The first action object and the second action object are selected from multiple action objects. The system executes the plan, and outputs a value associated with the third concept object. | 12-25-2014 |
20140380269 | VERIFICATION OF COMPUTER-EXECUTABLE CODE GENERATED FROM A MODEL - In an embodiment, a model is sliced into a plurality of slices. A slice in the plurality of slices is selected. A portion of code, that corresponds to the selected slice, is identified from code generated from the model. The identified code is verified to be equivalent to the selected slice. Equivalence may include equivalent functionality, equivalent data types, equivalent performance, and/or other forms of equivalence between the selected slice and the identified generated code. | 12-25-2014 |
20150046899 | PRESCRIBING A SOFTWARE ARCHITECTURE FOR IMPLEMENTING SERVICE INTEGRATION - An approach is provided for prescribing a software architecture to implement service integration. To determine first and second products, a first weight of a first software architecture is multiplied by weights of first requirements of a service and a second weight of a second software architecture is multiplied by weights of second requirements of the service. The first and second requirements are satisfied, respectively, by first and second sets of responses respectively associated with the first and second software architectures. A first summation of the first products is determined to be greater than a second summation of the second products. Based on the first summation being greater than the second summation, the first software architecture instead of the second software architecture is prescribed to realize the service in a service integration implementation. A work effort required to utilize the first software architecture to realize the service is estimated. | 02-12-2015 |
20150067637 | METHOD AND SYSTEM FOR SPECIFYING AND ENFORCING EXTENSIBILITY OF SOFTWARE APPLICATIONS - The method includes generating at least one base object, and generating at least one extendable object associated with the base object, the extendable object defining an insertion point and is configured to enable addition of new functionalities to an application including the at least one base object. | 03-05-2015 |
20150074634 | BUSINESS SUITE FRAMEWORK FOR DEVELOPING SOFTWARE APPLICATIONS - A system modeler may provide a framework for the development of business applications using object oriented concepts. The framework may expose selected attributes of these classes through a Graphical Presentation Interface. When a Graphical Presentation Interface is defined for a class, System Modeler may automatically generate a. project containing the corresponding DataModels that can be used by Client Application developers in a variety of Client technologies. The generated DataModels may be synchronized with any changes made to the class definitions in System Modeler. When an attribute is modified in the System Modeler class, then the change will automatically filter through to the corresponding DataModels used by the Client Application. | 03-12-2015 |
20150095877 | REUSABLE COMPONENT IN A MODELING ENVIRONMENT - In an embodiment, a modeling component generated in a first modeling environment can be implemented in a second modeling environment. The modeling component is executed in the first modeling environment. A first behavior of the modeling component in the first modeling environment is obtained based on the executing. The modeling component is then executed in the second modeling environment. A second behavior of the modeling component in the second modeling environment is obtained based on the executing the modeling component in the second modeling environment. The first behavior is compared to the second behavior. Based on the comparing, it is verified that the second behavior of the modeling component complies with one or more modeling requirements of the second modeling environment. The second behavior of the modeling component may be implemented in the second modeling environment. | 04-02-2015 |
20150100942 | UML MODEL INTEGRATION AND REFACTORING METHOD - The UML model integration and refactoring method steps include extending the metamodels, composing an integrated UML model derived from the extended metamodels, defining refactoring opportunities and transformation operations during the integrated UML composition, and applying a set of composite refactorings to remove an identified smell from the integrated UML model. | 04-09-2015 |
20150106781 | VERIFICATION OF UML STATE MACHINES - A method, apparatus and computer-implemented method, the method comprising: receiving a statechart comprising a complex feature; and replacing the complex feature with a transformed feature, thereby transforming the statechart to a second statechart, wherein replacing the complex feature comprises: creating an auxiliary variable or a default state; changing a value of the auxiliary variable at the beginning of the transformed feature and changing the value of the auxiliary variable again at its end; and taking a transition from the default state, such that the transition occurs in accordance with the value of the auxiliary variable. | 04-16-2015 |
20150106782 | USING SPREADSHEETS AS A BASIS FOR ENHANCED APPLICATION DEVELOPMENT - Systems, methods, and software are disclosed herein for designing applications. In an implementation, a method comprises examining a spreadsheet to identify a plurality of spreadsheet components of the spreadsheet with which to generate a plurality of application components for potential inclusion in a software application under design. The method also comprises receiving user input comprising a plurality of design instructions to include in the software application at least some of the plurality of application components and generating at least an instance of the software application comprising the plurality of application components. | 04-16-2015 |
20150106783 | PARALLEL DYNAMIC PROGRAMMING THROUGH RANK CONVERGENCE - The techniques and/or systems described herein implement parallel processing of a dynamic programming problem across stages and/or clusters by breaking dependencies between stages and/or clusters. For instance, the techniques and/or systems may identify dependencies between sub-problems of the dynamic programming problem and group the sub-problems into stages. The techniques and/or systems may also group the stages into clusters (e.g., at least two clusters to be parallel processed). Then, the techniques and/or systems generate one or more solutions to use instead of actual solutions so that the dynamic programming problem can be parallel processed across stages and/or clusters. | 04-16-2015 |
20150113498 | MODELING CUSTOMIZATIONS TO A COMPUTER SYSTEM WITHOUT MODIFYING BASE ELEMENTS - A customization environment uses a customization system that models customizations to a base computer system. Each set of customizations is stored as a separate extension package, which is stored separately from the code for the base system. During runtime, the extension packages are discovered in a runtime environment and applied to extend the base system, without overwriting any of the code for the base system. | 04-23-2015 |
20150113499 | RUNTIME SUPPORT FOR MODELED CUSTOMIZATIONS - A base assembly generated from a model in a computer system and a customization assembly generated from a customization model that models customization to the computer system are run separately. The customizations are applied to extend the base system, without overwriting any of the code for the base system. | 04-23-2015 |
20150143329 | METHODS AND ARRANGEMENTS FOR PROCESSING AND PRESENTATION OF INFORMATION - Embodiments may implement processing and presentation of information with, e.g., standalone and/or application integration, object-oriented, hierarchical architecture, in the form of, e.g., an add-in application or a computing platform for creating, modifying, interpreting, compiling, and/or executing an application. Embodiments may be implemented as a discrete computing platform or as an overlay, allowing interoperability with capabilities of the overlaid platform. Many embodiments correspond to computing platforms that support a new computing paradigm, a definition-centered paradigm. The definition-centered paradigm is an object-oriented hierarchy referred to as a Model hierarchy with one or more data structures referred to as Entities and, in many embodiments, interface types referred to as Relations. Each Entity has a defined type that specifies the data structure layout and supported functions. Each data structure type may implement a set of Relations, forming part of a type hierarchy that affects the resolution of the Model. | 05-21-2015 |
20150149979 | DYNAMIC MODEL BASED SOFTWARE APPLICATION DEVELOPMENT - A system and method of dynamically generating software is provided. Applications are created in a set of workflow models which are tested in an interpretive test environment. The models are stored in a versioning repository and code generation templates created for the models. Source code is generated and compiled for the application. Modifications to the models are tested and incorporated into a modified version of the application after subsequent testing of the model and the modified, compiled application. The modified version of the application is returned to the test environment where it becomes the basis for testing future modifications. | 05-28-2015 |
20150293749 | SYSTEMS AND METHODS FOR CREATING APPLICATION INTERFACES FOR FORMING AND SOLVING PROBLEMS IN A MODELING SYSTEM - An apparatus for generating an application data structure includes a physical computing system comprising processor(s), input device(s), display(s), and memor(ies). The memory includes executable instructions that cause a processor to perform the acts of embedding a multiphysics model data structure for a physical system in an application data structure. Application features are determined to add to the application data structure. First data is added representing a form feature for the application features for the model of the physical system. Second data is added representing at an action feature for the application features. The second data is associated with at least one modeling operation to define a sequence of operations for modeling the physical system. The application data structure is updated including the added first and second data and the associating defining the sequence of operations. The updated application data structure is stored on the memory device(s). | 10-15-2015 |
20150293755 | SYSTEM AND AUTOMATED METHOD FOR CONFIGURING A PREDICTIVE MODEL AND DEPLOYING IT ON A TARGET PLATFORM - Method and system for configuring a model and deploying it on a target. The method may include using a processing unit, automatically generating a plugin based on a statistical model, the plugin including variables and issue definitions extracted from the model; and deploying the plugin on a target platform. | 10-15-2015 |
20150302298 | TOOLING FOR IMPLEMENTING BUSINESS PROCESSES USING WEB SERVICES - Business processes are implemented using a collection component for storing system knowledge comprising usage history and user input relative to activities within community of users, where the system knowledge comprises at least a folksonomy. At least one of a user client component interacts with the data collection component to enable a corresponding user to contribute user-derived information to the folksonomy and a monitoring component monitors activities associated with the community of users and interacts with the data collection component to contribute usage information to the system knowledge. Still further, a composition design application interacts with a user to build and/or modify processes built using services, wherein the composition design application recommends candidate services that can implement aspects of the business processes based upon information derived from the system knowledge. | 10-22-2015 |
20150309769 | TASK MANAGEMENT INTEGRATED DESIGN ENVIRONMENT FOR COMPLEX DATA INTEGRATION APPLICATIONS - Embodiments presented herein provide task management capabilities for designing a complex data integration workflow in an integrated design environment (IDE). A task management tool of the IDE allows a developer to tag various stages of a data integration workflow in a non-linear manner. When the task management tool receives a tag for a given stage, the task management tool identifies incomplete tasks associated with the stage and generates a task list that includes the incomplete tasks. The developer may return to completing any of the tasks in the workflow in any sequence as desired. | 10-29-2015 |
20150309772 | Declarative Software Application Meta-Model and System for Self-Modification - A solution providing for the dynamic design, use, and modification of models using a declarative software application meta-model that provides for self-modification of a collection of the models is provided. The solution can enable continuous real-time testing, simulation, deployment, and modification of the collection of the models. A model in the collection of the models can represent an entity or a function and can be included in a set of related models. Additionally, a set of related models can include a plurality of sets of related models. The collection of the models can represent, for example, one or more software applications, processes, and/or the like. | 10-29-2015 |
20150317127 | SYSTEM FOR METAMODELING UNIFICATION - The present invention relates to a metamodeling unification system, in particular to a system for metamodeling unification to guarantee interoperability between an UML model of IEC 61850 and an UML model of IEC 61970. | 11-05-2015 |
20150331675 | MODELING REPRESENTATIONAL STATE TRANSFER APPLICATION PROGRAMMING INTERFACES - Modeling representational state transfer application programming interfaces by performing the following steps: (i) receiving REST schema information defining a REST schema; (ii) organizing into a non-cyclic object graph according to a hierarchy, a set of hypertext transport protocol (HTTP) endpoints, with each endpoint respectively including a portion of the REST application so that the set of HTTP endpoints are individually addressable by uniform resource locator (URL) addresses; and (iii) for each HTTP endpoint of the set of HTTP node types, assigning node types based on the REST schema. | 11-19-2015 |
20150347533 | SEMANTIC CONTENT ACCESSING IN A DEVELOPMENT SYSTEM - A development system comprises, in one example, a development module configured to receive user development inputs to develop elements of a computer system. The elements comprise types modeled in the computer system. The development system comprises a user interface module configured to generate a user interface display with user input mechanisms that receive a user search query for searching the elements of the computer system. The development system comprises a search module configured to identify a type-based search parameter for the user search query and to obtain a set of search results by performing an element search based on the user search query and the type-based search parameter. | 12-03-2015 |
20150370541 | VERIFICATION OF A MODEL OF A GUI-BASED APPLICATION - A method may include receiving a model of a graphical user interface (GUI) based application that includes a plurality of paths. The method may further include determining one or more paths of the plurality of paths that each include a pattern that satisfies a rule-pattern. The rule-pattern may be based on potential inaccuracies in the model as indicated by the pattern. The method may additionally include verifying whether the model is consistent with the GUI-based application. The verification may be based on a prioritization of a determination of whether the one or more paths are consistent with the GUI-based application. The prioritization of the one or more paths may be based on the one or more paths each including the pattern. | 12-24-2015 |
20150378684 | MOBILIZE WEBSITE USING REPRESENTATIONAL STATE TRANSFER (REST) RESOURCES - In an approach for mobilizing a web application, a processor receives a representational state transfer (REST) resource of a web application. A processor analyzes the REST resource to identify a pattern in the REST resource. A processor retrieves a template corresponding to the pattern in the REST resource. A processor generates a mobile web application based, at least in part, on the REST resource and the template. | 12-31-2015 |
20150378685 | MOBILIZING AN EXISTING WEB APPLICATION - In an approach for adjusting a web application to comply with user interface capabilities of a device type, a processor receives user interface capabilities of a device type. A processor analyzes a web application for compatibility with the user interface capabilities of the device type. A processor determines at least one user interface element to be modified within presentation of the web application on the device type based on the analyzed compatibility of the web application with the user interface capabilities of the device type. A processor generates a version of the web application compatible with the user interface capabilities of the device type. | 12-31-2015 |
20160004512 | METHOD OF PROJECTING A WORKSPACE AND SYSTEM USING THE SAME - A method of projecting a workspace includes the following steps. Firstly, a projectable space instance which is instantiated from a unified script is provided through a URI (uniform resource identifier). The unified script is defined to configure at least one of an matterizer, information and tool to model a workspace. The projectable space instance is used for building a projected workspace corresponding to the workspace so as to provide an interface for operating at least one of the matterizer, the information and the tool to perform a task. Then, a projector is used to parse the projectable space instance and build a working environment to configure at least one of the matterizer, the information and the tool. Consequently, the projected workspace is executed for providing interaction between at least one user and the projected workspace. | 01-07-2016 |
20160004514 | METHOD OF UNIFYING INFORMATION AND TOOL FROM A PLURALITY OF INFORMATION SOURCES AND COMPUTER PROGRAM PRODUCT AND MATTERIZER USING THE SAME - A method of unifying information and tool from a plurality of information sources includes the following steps. Firstly, an access scheme is provided to retrieve attributes and an associated link from an original information and/or attributes and an associated link from an original tool. Then, the original information is modeled into a unified information unit with a first unified data model by re-organizing the attributes and the associated link of the original information, and/or the original tool is modeled into a unified tool with a second unified data model by re-organizing the attributes and the associated link of the original tool. A format of the original information is modeled by the first unified data model and/or a format of the original tool is modeled by the second unified data model. | 01-07-2016 |
20160019030 | APPLICATION MODEL FOR IMPLEMENTING COMPOSITE APPLICATIONS - Embodiments are directed to providing an application model for implementing composite applications and to providing a declarative programming model and distributed runtime for creating and executing composite applications. In an embodiment, a computer system instantiates an application model. The application model allows users to compose composite applications. The composite applications are configured to run on both distributed computing systems and local computing systems. The computer system receives user input at the instantiated application model. The user input indicates which composite application components are to be used in conjunction with each other to form the composite application. The computer system also provides the composite application on a distributed computing system and/or a local computing system. | 01-21-2016 |
20160019033 | EXPRESSIVE GENERIC MODEL TECHNOLOGY - Various of the disclosed embodiments concern systems and methods for constructing enterprise applications. A universal Smart Enterprise Information platform can operate as a hub for data retrieved from different internal and external sources and provide an integrated and automated way for enterprise information to be managed. More specifically, the platform is able to retrieve data from one or more sources and construct models that represent, for example, common business scenarios. The platform employs assorted software development techniques to bring together the business, design, and runtime domains. Using a unique development paradigm (“CORTEX”), the models can be used to construct an application with minimal programming efforts. The platform allows a user to construct compelling applications using preexisting structures that can be automatically converted to models, unlike conventional software development techniques that require large sections of code to be rewritten each time a new model or program is created. | 01-21-2016 |
20160026441 | Recursive ontology-based systems engineering - The present disclosure proposes a new model engineering method and system that permits the creation of application systems without the need of program development. The system allows organizations to search for high performance development teams and methods, and develop high quality solutions. The present disclosure covers the three central areas of systems engineering: (1) a method for creating models which represent reality in a standardized way; (2) a procedure for transforming models into computable artifacts, that is, computer systems that behave as specified in the model; and (3) a collaborative method based in knowledge representations. | 01-28-2016 |
20160048375 | SIMULATION-GUIDED INCREMENTAL STABILITY ANALYSIS - A computer system may seek to identify at least one contraction metric that satisfies contraction conditions for a design of a dynamical system. The computer system may do so by formulating a search for a candidate contraction metric that is suspected of satisfying the contraction conditions for the design of the dynamical system from a set of simulation traces that describe the behavior of the dynamical system for a specific set of operating conditions. The search for the candidate contraction metric may then be performed. | 02-18-2016 |
20160062746 | Software Defined Network Controller - Concepts and technologies are disclosed herein for providing and using a software defined network controller. A software defined network controller can be provided by a computing system that includes a processor. A service model that represents a service can be obtained. A network model that represents network resources that support the service can be obtained. Resources that support the service can be determined. Templates can be accessed to identify templates that relate to the resources. The templates identified can be assembled to obtain a template-based representation of the service. The template-based representation can be executed to determine if the service is ready for deployment. | 03-03-2016 |
20160070546 | COMPUTER PROGRAMMING SYSTEM AND METHOD - A method of computer programming includes the steps of making a writable system catalog, and developing grammar by building an abstract grammar tree. Another method of computer programming involves use of a data model and a user interface, and includes the step of decoupling the user interface from the data model. | 03-10-2016 |
20160077807 | CLOUD BASED SERVICE DESIGN INHERITANCE - Designing a cloud based service from a component palette can include providing a designer with a component palette. The component palette can include a plurality of component types each including an identification of the component type, a property defining the component type, and a relationship rule defining a relationship with another component type. The component palette can include a component template corresponding to a component type, comprising a specialized variant of the component type, wherein the component template inherits the property and the relationship rule of the component type. Designing can include receiving a request for a new component type from the designer, receiving an indication of one component type from which to derive the new component type, and deriving the new component type from the indicated one component type inheriting the property and the relationship rule from the indicated one of the plurality of component types. | 03-17-2016 |
20160077808 | METHOD AND SYSTEM FOR PROVIDING CONTENT - A computer-implemented method for generating one or more applications, the method including the steps of: accessing a template for holding content; populating the template with the content; generating the one or more applications, configured for a plurality of computing platforms, based on the populated template; and making the applications available for distribution by a server. | 03-17-2016 |
20160077812 | EXTENSIBLE CONTEXT BASED USER INTERFACE SIMPLIFICATION - Embodiments of the present invention address deficiencies of the art in respect to modeling tools and provide a method, system and computer program product for extensible context based user interface simplification of modeling components for a modeling tool. In an embodiment of the invention, a method for extensible context based user interface simplification can be provided for a model driven development tool. The method can include detecting a context change to a new context in a model driven development tool, locating tool items mapped to the new context, and displaying the located tool items in the model driven development tool. | 03-17-2016 |
20160085519 | DETERMINATION OF SIGNALS FOR READBACK FROM FPGA - A method for automatically determining models signals of an FPGA program which are readable from the FPGA with the aid of a readback following an FPGA build, including the following steps: generating an FPGA model and generating an FPGA code from the FPGA model, the method comprising the additional step of an automatic analysis for the purpose of identifying signals which are readable from the FPGA with the aid of a readback, prior to the completion of the step of generating the FPGA code from the FPGA model, and the method comprises the step of outputting signals which are readable from the FPGA with the aid of a readback. A data processing device is also provided for carrying out the method. | 03-24-2016 |
20160092177 | METHOD AND SYSTEM FOR MODEL DRIVEN DEVELOPMENT - Embodiments of the present invention disclose a method for providing a technical solution for model driven development. Program code is analyzed to determine the execution sequence of states of the program code. The program code is generated by performing a first transformation to a model. The model includes an abstract description of a business implemented by the program code. At least part of the statement of the program code is grouped into functional blocks. A visual representation of the program code is created. The visual representation is based on the execution sequence and the functional blocks. A code snipped is determined to be preserved in the program code based on a user's annotation of the visual representation. The code snippety is to be preserved in new program code generated by performing a second transformation to the model. The second transformation is executed after the first transformation. | 03-31-2016 |
20160092178 | METHOD AND SYSTEM FOR MODEL DRIVEN DEVELOPMENT - Embodiments of the present invention disclose a system and computer program product for providing a technical solution for model driven development. Program code is analyzed to determine the execution sequence of states of the program code. The program code is generated by performing a first transformation to a model. The model includes an abstract description of a business implemented by the program code. At least part of the statement of the program code is grouped into functional blocks. A visual representation of the program code is created. The visual representation is based on the execution sequence and the functional blocks. A code snipped is determined to be preserved in the program code based on a user's annotation of the visual representation. The code snippety is to be preserved in new program code generated by performing a second transformation to the model. The second transformation is executed after the first transformation. | 03-31-2016 |
20160098251 | EXTENSIBLE META MODEL FOR CAPTURING SOLUTION PATTERNS - A method for capturing patterns and associated points of variability includes providing an XML schema defining elements representing different point of variability (POV) types for a pattern. The elements belong to an XML schema “substitution group” to enable the POV types to be substituted for one another. In selected embodiments, the method enables a pattern author to add new or custom POV types to the “substitution group,” thereby allowing the pattern author to extend the pattern meta model to include new POV types. Once the desired POV types are defined, the method enables the pattern author to generate an instance of the XML schema, defining the points of variability for a specific pattern, using the elements defined in the XML schema “substitution group.” A corresponding apparatus and computer program product are also disclosed and claimed herein. | 04-07-2016 |
20160098255 | GENERATING A SERVICE COMPONENT ARCHITECTURE (SCA) MODULE WITH SERVICE ORIENTED ARCHITECTURE (SOA) MODEL ELEMENTS - A system and associated method for generating a Service Component Architecture (SCA) module with Service Oriented Architecture (SOA) model elements. A service model corresponds to a process model that has activities and a process flow. Services of the service model are respectively associated with the activities. Each service is determined to employ only one service operation definition to render a message specification of a respective activity that is associated with each service. The activities, the process flow, and the message specification are utilized to produce the SCA module in executable implementations. | 04-07-2016 |
20160103661 | INTEGRATED DEVELOPMENT ENVIRONMENT FOR HETEROGENEOUS CLIENT/SERVER ENVIRONMENTS - The present disclosure describes methods, systems, and computer program products providing an integrated development environment for client/server environments. One computer-implemented method includes reading a derived business application data model (BADM) associated with a business application into an integrated development environment (IDE), defining a client application data model (CADM) for a client application, defining at least one data mapping rule (DMR) to map at least data translations between the BADM and the CADM, developing the client application based upon at least the CADM, developing at least one web service based upon the BADM, CADM, and the at least one DMR, generating the client application and the at least one web service, and deploying the client application, the at least one web service, and the at least one DMR. | 04-14-2016 |
20160124718 | CONTEXT-BASED GENERATION OF MEMORY LAYOUTS IN SOFTWARE PROGRAMS - The disclosed embodiments provide a system that facilitates execution of a software program. During operation, the system determines a structure of a software program and an execution context for the software program from a set of possible execution contexts for the software program. Next, the system generates memory layouts for a set of object instances in the software program at least in part by applying the execution context to the structure independently of a local execution context on the computer system. The system then stores the memory layouts in association with the software program. | 05-05-2016 |
20160139886 | METHOD OF EXCHANGING DATA DESCRIPTIVE OF TECHNICAL INSTALLATIONS - A method of exchanging data descriptive of technical installations between at least two applications is provided, a said application being able to provide and/or to consume data according to an associated application data model, the method allowing interoperability between applications by virtue of an exchange of the data expressed and formalized through at least one chosen standard having an associated data model and associated exchange formats, implemented by a programmable device. For at least one application, the method includes the integration (T | 05-19-2016 |
20160147507 | APPARATUS AND METHOD FOR CONVERTING A PROCEDURE MANUAL TO AN AUTOMATED PROGRAM - A computing device receives a query about at least one concept and at least one document associated with the at least one concept. The computing device accesses a plurality of models created based on information in a labeled database. The computing device decodes information in the at least one document using the plurality of models. Responsive to the decoding, the computing device generate a program with steps associated with the at least one concept. | 05-26-2016 |
20160154628 | PROCESS CONTRIBUTIONS IN A METHOD ARCHITECTURE | 06-02-2016 |
20160154631 | METHOD AND SYSTEM FOR MACHINE COMPREHENSION | 06-02-2016 |
20160154632 | GENERATING A PRODUCT MODEL | 06-02-2016 |
20160170716 | System and Method for Creating a Development and Operational Platform for Mobile Applications | 06-16-2016 |
20160170722 | System and Method for Managing and Using Data Model | 06-16-2016 |
20160253156 | SYSTEM AND METHOD FOR SOFTWARE APPLICATION LIFECYCLE MANAGEMENT | 09-01-2016 |
20160378435 | Automatic Discovery of Comparable Features Based on N-gram Analysis - According to one aspect of the present disclosure, a computer-implemented method is disclosed in which a software development log whose entries describe potential features for a future release of a first software program is accessed to obtain a text description of a feature from an entry. The text description is decomposed using a predefined n-gram decomposition technique to produce a first set of n-grams. The method includes determining whether a second software program includes the feature. The determining includes comparing the first set of n-grams to a second set of n-grams which describe the second software program, and calculating a similarity metric based on the comparing that indicates an extent to which matches for the n-grams in the first set are present in the second set. The software development log is updated based on the determining. | 12-29-2016 |
20170235550 | GENERAL SOFTWARE MODELING METHOD TO CONSTRUCT SOFTWARE MODELS BASED ON A SOFTWARE META MODEL | 08-17-2017 |
20180024815 | SYSTEM AND METHOD FOR ITERATIVE GENERATING AND TESTING OF APPLICATION CODE | 01-25-2018 |
20180024818 | FRAMEWORK FOR ON DEMAND FUNCTIONALITY | 01-25-2018 |
20180024832 | COGNITIVE FEATURE ANALYTICS | 01-25-2018 |
20190146759 | MODEL BUILDING SERVER AND MODEL BUILDING METHOD THEREOF | 05-16-2019 |