kinodb applications deliver benefits far earlier than other solutions, whilst:
Development traditionally involves developers translating business requirements into technical code. Developers specialise in the implementation of specific technologies and, as these technologies change, developed systems need to be updated to avoid a slide into obsolescence.
Conventional systems development results in the business functions of a system and its technical implementation becoming inextricably intertwined, so changing one requires changes to the other. This means that system owners and maintainers face a choice between the expense and risk of successive changes to a system, or simply allowing a system to turn into a legacy problem over a few years.
And as business requirements change, developers face the same problem. Systems fall out of sync with users' needs, and again there's the need to successively make changes, leading to the gradual attrition that results from continual modification. Again, it's the intermingling of business requirements with their technical implementation that creates this conflict.
kinodb changes the way that business applications are developed, deployed and maintained.
In the same way that CAD applications revolutionised engineering design and manufacturing processes, we have separated the business and technical aspects of systems development.
The kinodb platform allows developers to build a model of the application instead of building the technical components themselves.
At the core of our technology lies a metadata model of the application - all of it, from physical data structures to the security model, processing rules, reporting and interfaces.
This model contains no technology, so in the same way that a 3D CAD model can be used by a variety of rendering, visualisation and manufacturing technologies, the application model exists independently of its technical implementation.
This fundamentally changes the development process in the following ways:
Removing the need to hand-craft technical code means that implementation takes a small percentage of the time normally required: for a typical project, using kinodb generally reduces development time by around 85%, and often significantly more.
This speed means that development can be truly agile, with users and developers iteratively defining and refining functionality to precisely meet requirements.
As new database versions and platforms appear, existing applications are made compatible with them, not by changes to the applications themselves, but by updates to the kinodb platform. This also means that an existing application deployed to a workgroup of 20 users using a free-to-use database such as MariaDB or MySQL can be migrated - literally at the click of a mouse - to an Oracle Enterprise implementation supporting thousands of concurrent users.
Just keeping up with new browser versions causes major headaches to application developers and maintainers. Again, by separating the technical implementation from the application definition, kinodb applications can support the full range of corporate and end-user browsers. A consequence of this is that applications developed over a decade ago can now be used on smartphones and tablets - devices that did not even exist when the applications were developed - and this has again been achieved without requiring changes to the applications themselves.
kinodb applications are equally at home in server rooms or the cloud, using resilient database management such as Amazon’s RDS or Oracle’s Cloud Infrastructure. Developers can work on their laptops or on shared platforms as required.
And as new functionality is added to the framework - powerful end-user reporting capabilities, XML interfacing, graphing support, single sign-on and so on - these become available for use within existing systems.
As the whole of the application is defined within the model, it's easy to assess the scope and impact of any proposed change. Large-scale systems that are unmanageable when implemented using conventional tools suddenly become simple to maintain, as the technical aspects of making a change within a system of any scale (for instance checking hundreds or thousands of SQL statements after a change to data structures) are handled by the model.
This makes enhancing existing systems far simpler than is normally the case, allowing the swift, safe and cost-effective enhancement of systems as business and regulatory environments change.
Systems can be maintained over years to meet changing requirements, even when their original developers are no longer available.
Business applications all too frequently constrain the business rather than enabling it.
Analysts and developers are familiar with the experience of gathering requirements and delivering functionality, only to discover that requirements gathered three months ago are no longer current. Conventional development tools don't cater for this pace of change as they require analysis and management of the many dependencies that exist in any complex system - the database structures, data validation, business rules, security model, reporting, external interfaces and so on.
Conventionally, changing a system that is in use is difficult and risky, and therefore time-consuming and expensive. Making changes requires detailed knowledge of the same dependencies, and these will be hidden in reams of technical code, often created by developers no longer available to the maintenance project.
kinodb provides a simple solution to both of these problems. The application's definition is recorded as a model, so all dependencies can be immediately visible to the developer. The impact of any proposed change can therefore be determined swiftly and definitively. The development environment incrementally loads changes to the application definition as each is made, so a set of changes can be tested one by one and then fully, immediately on completion.
The incremental delivery of changes is robust and quick - kinodb includes sophisticated change management functionality that allows the managed propagation of sets of changes between environments. This means that changes can be delivered into a test environment whenever appropriate: it takes a couple of clicks to mark a set of changes as ready for distribution, and another couple to propagate them to a test or production environment. A full change history is maintained across development, test and production environments, so a developer can see when (for instance) a field was created, when its properties were changed and by whom.
Today's information systems are increasingly sophisticated in terms of their processing requirements, their need to communicate with other systems, and their user interfaces.
Typically these systems are implemented using a number of separate technologies, from database platform to development language, external interface tools, user interface development, theme management and so on.
A change anywhere in the system may have unexpected consequences elsewhere, and determining these dependencies across a disparate set of technologies can present difficulties.
The kinodb application development and deployment framework covers all of the bases from the database server to the browser, recording all aspects of the application's design and implementation in a single coherent and consistent model. This means that the impact of a change can be seen across the whole of an application, and that a change made anywhere will be reflected - immediately - throughout the model.
A simple example of this is where a developer wishes to remove a field from a database table. The model produces a report detailing all uses of the field. Once the developer is satisfied that there will be no unwanted effects, the field is deleted. The definition of the column is removed from the database and the change is immediately effective across the running application: the next time that the table is queried, the column will not be referenced. Forms and reports will no longer include the deleted field; processing that involved that field will be removed. Elements in XML interfaces referencing the field will be deleted. All of this happens instantly, and the developer can see the impact of each change immediately.
Suddenly, Agile development becomes just that.
Most organisations are plagued by legacy applications that rely on unsupported technologies. These become increasingly expensive to maintain and block business innovation through their inflexibility. Adoption of newer (and typically more secure) versions of operating systems, database platforms and browsers may be prevented by the inability of legacy systems to operate with them.
Systems deployed using kinodb are immune to these problems.
Systems originally developed for use by Oracle 8 and Internet Explorer 5.5 are now being used with Oracle 12 and IE 11 / Edge (and Firefox, Safari etc.) and are also available to browsers on mobile phones and tablets, devices that didn't even exist when these systems were first deployed. All without change to the applications themselves, and saving their users multiples of the original development cost.
Developers don't have to write technical code, reducing development time by as much as 85% and greatly reducing the risk of technical errors in implementation
As the impact of any change can be investigated before it is made, applications can be maintained and enhanced with far lower risk, providing an unparalleled ability to keep pace with changing business requirements
kinodb handles the technical implementation of the application model, safeguarding applications against technical obsolescence
The productivity of the development environment enables truly 'Agile' development, with users able to see the results of changes faster than ever before
The speed of iteration means that opportunities for improvement can be exploited and blind alleys avoided as a normal part of the development process