Ka-Rapid Protoyping Platform
Feb' 2019
'ka-rapid prototyping platform' is a distinct stage in 'ka-product engineering' framework, where a product definition gets translated into a working prototype.
This platform is built around the idea of Low-Code automation.
About this article
This article details 'Ka-Rapid Prototyping Platform', its objectives, features, structure and technology. This is a part of ka-product-engineering documentations.
This 'rapid prototyping platform' can be used independent of other components of 'Ka-product engineering framework'. However, it integrates seamless with rest of the components, and we have observed immense value addition.
Hope this is of help to you!
The need
IT, has a natural affinity to operate on best practices & strong architectural principles. However, this has a side effect of IT drifting away from the core business it is trying to support and move towards its own silo.
Of late, there had been attempts to narrow the ridge between IT and the business it supports. Agile model is one such example of that attempt.
For startups built around IT capabilities, existence of this silo would be a disaster. It is difficult for any silo setup to support a reduced Time-To-Market or Fail-Fast. This has also been realized by established enterprises too.
These changing paradigms leave those in IT to be at a cross road between Business Expediency and Established best practices.
Ka framework attempts to merge these seemingly contradicting aspects through its best practices and tools.
Key drivers & objectives
Rapid prototyping
- To increase Time-to-Market and enable Fail-Fast.
- Quick “Concept to Prototype” – key for product’s market viability.
Seamless Extensibity
- Prototypes -to- MVP -to- Enterprise Scale
- Solution development purely driven by expediency often results in needing re-platforming or re-architecting as the solution evolves.
- Framework to allow same technical stack and architecture throughout its path of evolution from MVP to enterprise grade application.
Consistent design and implementation pattern
- As the solution evolves, expect different team(s) work on it at various stages. This may result in potential deviation in architecture & implementation styles.
- This negatively impacts solution Maintainability and Extensibility.
Common Engagement Platform
- Common engagement across solution stakeholders to enable collaboration, stakeholder’s ownership and eventual product success.
- Framework is expected to shrink the SILO between Product and Solution Owners, thereby encouraging a true Agile Development model.
Key aspects
Choice of technical stack,
- SPA: offers rich UI experience with a possible extension to mobile native solutions.
- RDBMS: Structured data storage chosen to help preserve data integrity.
- Service Layer: Traditional language based service to provide stability/extensibility & security.
Technical stack adopted by this framework,
- Angular: SPA front end framework.
- Azure: Cloud Platform.
- C#: Programming Language for service.
- Data Storage: MS SQL, Cosmos DB. Possible extension to Postgress, MongoDB, etc.,
- Python: Programing language for Micro Computer gateways.
- C++: Programing language for light weight Micro Controller based edge devices.
Structure of Ka-Rapid Prototyping Platform
Core platform features
- Distinct and decoupled Data, API & UI Stacks.
- Extensive Object Oriented Programming Model on all layers.
DB Layer
- Data Entity segregation through DB Schema.
- Strict enforcement of Data relations – Parent & Child.
- Strict enforcement of look-ups through Enumeration tables.
- Table design having a minimum level 2 normalization.
- Trigger based date Insert & Update fields for audits.
C# Business Layer Structure
- Standard functionalities covered by the framework template code.
- Developers have options to extend or override these features as required.
- ADO based data access, with .NET provided connection pooling.
- SQL Injection safeguard through Secured Parameterized Queries and request validation.
- Tuned for high volume concurrent OLTP transactions.
- Low level Data Access implementation to offer transparency & control in developer’s hand.
- Optional extensions provide ability to handle complex join based data retrievals.
- Business Entity Objects as the core of Business Logic Implementation.
- Business Entities have intrinsic secured encryption\hashing algorithms to protect from injection attacks.
- Developers offered with the option to extend functionality to meet specific application's needs.
- DB Transactions and connections managed at various levels in business logic, enabling developers to choose based on needs.
- API model, with standard predefined request and response formats.
- API Authentication and Authorization through standard HTTP Protocols and through custom record level access security.
- Request data validation inbuilt within the framework.
- Standardized Exception management and reporting, through HTTP response codes & Rich Custom Exception Models.
Frontend UI Layer (Angular)
- Modal–View–Controller based model.
- API service gateway layer to integrate seamlessly with APIs.
- Modal Data Entities based on API response object definitions.
- Standard, Framework provided controllers & Service API connections.
- Option to extend controllers based on application’s specific needs.
- Leverages component based UI control development, with default connection to controller and modal data.
Ka-Rapid Prototyping Platform - Code automation features at a glance
ka-Rapid Prototyping Platform addresses the objectives of 'Rapid Prototyping', 'Cost Effectiveness' & 'Common Engagement' through 'Code Automation'.
One of the drawbacks for any code Automation is the loss of flexibility in handling variations in application specific logic. One size fit all approach often causes constraints during solution development.
Next challenge for a code automation model is to choose between No-Code or Low-Code.
No code solutions are usually tend to be rigid and tend to obfuscates much of the needed context for developer’s, hindering extensibility and suppressing ingenuity.
Considering above factors, ka-Rapid Prototyping Platform adopts a Low Code Automation Model.
Ka’s Low Code model achieved through,
-
Standard Libraries and pre-built boiler Plate Templates.
-
Business Logic, specific to an application is auto generated as framework compatible Classes, Scripts and Codes.
Ka's approach towards low-code automation
Software platforms built on 'ka-Rapid Prototyping Platform' has a combination of 'template classes' and manual custom extensions.
All the “Template Classes and Scripts” are generated through Code Automation
- This removes the heavy lifting from developers, leaving the manual work just to where it is necessary to meet specific application’s needs.
- Proof of Concepts can be created with minimal manual code.
- This forces developers to be engaged in the solution, rather than Click and Forget (as in the case of No-Code solutions).
How ka's code automation works?
Product Specifications
- Create product definitions which contains 'actors', 'journey' & 'interactions'.
- 'ka-product conceptualization' framework works seamlessly with 'ka-rapid prototyping platform'.
- Product definition feeds into the code automation engine to code generation.
Technical Specifications
- Technical specification created using the 'product definition'.
- Technical specification includes,
Data design.
Business entity definitions and design.
API contract definitions & security specs.
UI component design, to the level of individual controls and their data bindings.
​- These Technical specs are transferred to an Excel (or) csv format. Framework requires this bare minimum technical specification documentation.
- This technical specification is fed into Code Automation Engine to generate code.
Code Generation Engine
- Code Automation Engine consumes the excel feed file and generates KA compliant,
SQL Scripts for DB creation.
Framework template C# API code.
Framework template Type-Script code.
Framework template Angular component code.
- These code generation typically happens on developer’s machine.
Code Integration
- Developers develop their extended business logic manually. Manual code integrates seamlessly with the generated code if it adheres to ka protocol.
- Final solution is generated by compiling manually generated code along with the auto generated code.
- Code is checked-in from local system to code repository (git).
- Code is Built and Deployed using to DevOps pipeline.
Meta data for ka's low code automation
Data entity definition
- Schema, tables and fields are captured in this definition.
- DB scripts generated out of these definitions.
- Business logic layer's data access classes generated using these definitions.
Business Entity definition
- Business data entities defined as an extension to DB entities.
- Data entity in business logic layer generated using this definition.
API Definitions
- API request & response format definitions.
- Definition includes request data validation conditions.
- Used for generating request & response definition object classes for C# API code.
- Used for generating API gateway typescript classes to use in Angular App.
UI Definitions
- Above definition used for generating Angular controller typescripts and HTML UI components.
- This includes definition for UI controls and their generic behaviors.