Defining KDF
From KallestadWiki
Contents |
Project Goals
The Kallestad Development Framework is designed to be a robust application framework that maintains focus on some simple objectives:
- Speed
- Simplicity
- Extensibility
There are certainly a series of peripheral objectives that will affect the project as well.
Speed
The speed at which the KDF publishes data is of course dependent on the complexity and performance of the application shaping the data. Since the application can be arbitrarily defined, it is important for the framework itself to take advantage of as many optimizations as possible and to provide an interface for the most common functions that is as efficient as possible.
Abstraction inherently implies performance degradation. Purpose driven programs should always outperform abstractly defined programs because knowledge of the data model and the desired functionality surrounding that data model allows the programmer to streamline the code base. Unfortunately, applications are not always built to be as efficient as possible - in fact, I would be hard pressed to find a piece of reasonably complex software that exhibited maximum efficiency. To this end, the introduction of an abstraction layer can provide significant benefit while offsetting it's own performance hit by increasing performance elsewhere in the application.
The Framwork itself tries to maximize performance by taking advantage of several performance enhancing paradigms:
- Support for persistency models (i.e. FastCGI)
- Support for the use and reuse of shared cache resources
- Support for intermediary output cacheing
- Template output efficiency
- Statement Caching
- Pre-compiling as much code as possible
Simplicity
The more robust a framework becomes, the more complex it must get. Complexity is a matter of perception, however, for new developers. Google and Apple have made big names for themselves based on the perception that their products are both easy to use and powerful. Other vendors have made a ton of consulting money because of the perception that their products are too complex for an uncertified specialist to deal with. I'd like to position KDF among the former group.
Being a long time computer programmer, this is not an intuitive task and it will mean several iterations of user interface design before it becomes stable. There are a few founding principals that should be followed:
- Terminology should be intuitive - and not just for a seasoned programmer.
- Interface Elements should exhibit basic options only by default (don't make things look more complex than they need to) with an easy way to navigate towards more complex options.
- Input elements need to be task-streamlined.
- Other things as I think of them
Extensibility
The framework itself should be limitlessly extensible. This of course is a very lofty goal, but it is not one that is unachievable. While the framework does provide a streamlined set of general functionality there are always reasons to go outside the box to get something accomplished.
Rather than provide an intense API providing access to the underlying language layer, the framework should provide direct access to the underlying language - and in the long term future direct access to any underlying language.
This power pushes a great deal of responsibility off on developers and should not be taken lightly.
