Abstract Machine Model for Rapid Backend Service Prototyping

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Prototyping and development of mobile applications often require significant programming from scratch or the combination of multiple libraries, which can delay development and necessitate advanced programming capabilities, making it challenging for users to efficiently create and deliver development projects.

Innovation Solution

A system that utilizes an abstract machine model to generate program code for development projects by selecting an appropriate abstract machine based on use case information, with a host device employing machine learning techniques to suggest modifications and simplify the development process, reducing the need for extensive programming expertise.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If programming from scratch or combining multiple libraries is used to develop mobile applications, then the application functionality can be fully customized, but the development time increases and advanced programming capabilities are required

Engineering Contradiction:
Improveapplication functionality customizationVSAvoiddevelopment time
Core Design Contradiction:
Adaptability or versatilityVSLoss of time

Solution Approach 1:

The patent applies preliminary action by pre-defining common application patterns, data structures, and business logic templates that can be directly selected and customized. Instead of programming from scratch, developers can choose from pre-built patterns for common functionalities like user authentication, data synchronization, and notification systems, significantly reducing development time while maintaining customization capability.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

The patent uses copying by providing reusable code templates, data models, and implementation patterns that can be copied and adapted for different projects. These pre-defined patterns capture proven solutions to common mobile application challenges, allowing developers to copy and modify them rather than creating new solutions each time, thus reducing both time and expertise requirements.

Inventive Principle:
Principle #26Copying

2Adaptability or versatility

If programming from scratch is used to develop mobile applications, then unique functionality can be achieved, but the required programming expertise increases

Engineering Contradiction:
Improveapplication functionalityVSAvoidprogramming expertise required
Core Design Contradiction:
Adaptability or versatilityVSEase of operation

Solution Approach 1:

The patent applies this principle by providing disposable, pre-defined code templates and patterns that can be quickly selected and discarded or modified as needed. Rather than requiring developers to build complex, reusable architecture frameworks from scratch, the system offers lightweight, purpose-specific templates that can be dropped into projects and customized minimally, reducing the expertise barrier while maintaining functionality.

Inventive Principle:
Principle #27Cheap short-living objects (Disposable)

Solution Approach 2:

The patent uses parameter changes by allowing developers to customize pre-defined patterns through simple parameter configuration rather than complex programming. Instead of writing code to implement common functionalities, developers can adjust parameters such as data sources, display formats, and behavior options within the templates, making the system accessible to users with limited programming expertise while still achieving unique application functionality.

Inventive Principle:
Principle #35Parameter changes

3Adaptability or versatility

If multiple libraries are combined to achieve application functionality, then comprehensive features can be implemented, but the complexity of the development process increases

Engineering Contradiction:
Improveapplication featuresVSAvoiddevelopment process complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent applies merging by consolidating multiple library functionalities into unified, pre-integrated patterns. Instead of requiring developers to select, import, and integrate multiple separate libraries for authentication, data storage, networking, and UI components, the system merges these functionalities into cohesive patterns that work together seamlessly, reducing development process complexity while maintaining comprehensive feature sets.

Inventive Principle:
Principle #5Merging (Combining)

Solution Approach 2:

The patent implements universality by designing patterns that can serve multiple functions simultaneously. For example, a single pattern might handle data synchronization, conflict resolution, and offline storage across different application contexts. This multi-functionality reduces the number of separate components needed and simplifies the development process while still providing comprehensive features across diverse application scenarios.

Inventive Principle:
Principle #6Universality (Multi-functionality)

Data Source

PatentUS9864585B2Rapid prototyping of backend services
Publication Date: 2018.01.09 ACCENTURE GLOBAL SERVICES LTD
  • US9864585B2 patent drawing
  • US9864585B2 patent drawing
  • US9864585B2 patent drawing

AI summary

A device may determine use case information associated with a use case for a development project. The device may determine a set of use case objects associated with the use case based on the use case information. The device may select an abstract machine model. The abstract machine model may be associated with modeling the development project based on the set of use case objects. The abstract machine model may be selected from a set of abstract machine models associated with modeling development projects. The device may generate program code for the development project based on the abstract machine model and the use case information. The device may provide information associated with the generated program code.