Models are one of the main and most commonly used instruments in Computer Science and Computer Engineering. They have reached a maturity for deployment as the main tool for description, prescription, and system specification. They can be directly translated to code what enables us to consider models as the main tool for modern software development. Models are the power unit towards new programming paradigms such as true fifth generation programming. This paper introduces model-centered programming as one of the main ingredients and main tool of true fifth generation programming.
1.1
First generation languages – although low-level and machine-oriented at micro-code level - are still used for instruction-based programming. Second generation languages are assembly languages that can be translated to machine language by an assembler. Third-generation languages provide abstractions and features such as modules, variables, flow constructs, error handling, support packages, many different kinds of statements etc. Fourth generation languages are more user friendly, are portable and independent of operating systems, are usable by non-programmers, and have intelligent default. The fifth generation project has been oriented on logic programming and did not result in a wide acceptance and usage. The main supporting feature for programming is however that programs written in these languages are translated by compilers to programs in low-level machine languages.
Programs became an infrastructure of the modern society. At the same time, we
face a lot of problem for such infrastructure. Its maintenance, extension, porting,
integration, evolution, migration, and modernization become an obstacle and are already
causing problems similar to the software crisis 1.0. Programs are developed in a
variety of infrastructures and languages that are partially incompatible, in teams with
members who do not entirely share paradigms and background knowledge, at a longer
period of time without considering legacy problems at a later point of time, without
development strategies and tactics, and with a focus on currently urgent issues. A
crucial point is the development of critical software by non-professionals.
Programming has already changed to programming-in-the-large beyond
programming-in-thesmall and is going to change now to programming-in-the-mind. Moreover, systems
become more complex and less and less understandable by team members. The
software crisis 2.0 (e.g. [
We thus need better and more abstract techniques for development of our programs. We envision that true fifth generation programming can be based on models and model suites which can be automatically transformed to corresponding programs without additional programming. 1.2
Our notion and understanding of models and model suites is based on the
compendium on models in sciences and engineering [
A model is a well-formed, adequate and dependable instrument that effectively and successfully functions in utilization scenarios. It is adequate if it is analogous to the origins to be represented according to some analogy criterion, if is more focused (e.g. simpler, truncated, more abstract or reduced) than the origins being modelled, and if it sufficiently satisfies its purpose. Well-formedness enables an instrument to be justified by an empirical corroboration according to its objectives, by rational coherence and conformity explicitly stated through conformity formulas or statements, by falsifiability or validation, and by stability and plasticity within a collection of origins. The instrument is sufficient by its quality characterization (internal quality, external quality and quality in) such as correctness, generality, usefulness, comprehensibility, parsimony, robustness, novelty etc. Sufficiency is typically combined with some assurance evaluation (tolerance, modality, confidence, and restrictions). A well-formed instrument is called dependable if it is sufficient and is justified for some of the justification properties and some of the sufficiency characteristics. A model comes with its background, e.g. paradigms, assumptions, postulates, language, thought community, etc. The background its often given only in an implicit form.
A model reflects only some focus and scope. We thus use model suites that consists of a set of models, an explicit association or collaboration schema among the models, controllers that maintain consistency or coherence of the model suite, application schemata for explicit maintenance and evolution of the model suite, and tracers for the establishment of the coherence.
A typical model suite is used for co-design of information systems that is based on models for structuring, models for functionality, models for interactivity, and models for distribution. This model suite uses the structure model as the lead model for functionality specification. Views are based on both models. They are one kernel element for interactivity specification. Distribution models are additionally based on collaboration models.
Model-centered development is used in many branches of modern computer science and computer engineering. Model-as-Programs approaches will become the traction machine characterized by slow beginning at present and a progressive increase in speed. In the sequel we discuss this change of paradigms for database development. A similar approach has already been practiced for editing systems such as literate programming and as the LaTeX environment or such as compiler-compiler approaches for domain-specific languages. 1.3
Models and model suites became easy-to-use and easy-to-develop instruments that are used by everybody and therefore also by non-programmers. We envision that modern programming could be based on model suites that are translated to programs. As discussed in Section 2, this vision is already real for users that use advanced database development techniques. However, model-based database programming is used only in a less sophisticated and rather implicit form. Investigating the more advanced approach, we develop a path towards true fifth generation programming that is based on model suite development in Section 3. The entire framework is inspired by and can be considered as a generalization model-centric database development and modern specification approaches. 2 2.1
Conceptual schemata and models are widely used for database structure specification
and as a means for derivation of user viewpoints [
Viewpoints can be represented by view schemata that are defined on the main database schema by expressions given in an advanced algebra. Interaction models for business users are the third kind of models that are used in a database model suite. Collaboration models can be specified in a similar form and are based on viewpoints.
The usage of a conceptual model as a description model of thoughts and understanding in an application area is commonsense today. The usage for system realization must be based on specific properties of the database management platform and requires thus a lot of additional information. We thus enhance conceptual modelling by additional information. Pragmas and directives are essential elements that we use for enhancement of conceptual models for system realization. Pragmas have originally introduced for C and C++. Directives have been used as additional control units for compilation. 2.2
Conceptual models and schemata are often taken as an initial structure for logical and physical schemata. The transformation is still often based on some brute-force interpreter approach that requires corrective specification for integrity maintenance and for performance management at a later stage by experienced database operators. The transformation of integrity constraints is not yet automatically enhanced by enforcement mechanisms and control techniques. Procedural enhancement on the basis of triggers and stored procedures is still a challenge for database programmers. Performance support includes at the first step CRUD supporting indexing. Support for querying can be based on hints.
The transformation approach can however be based on rule-based compilation. Essentials of rule-based transformation are in a nutshell: syntactical and semantic analysis of the models and schemata according quality characteristics within the platform setting; preprocessing of the models and schemata to intermediate normalized models and schemata; extension of the models by support models for performance support; derivation of integrity maintenance and other support schemes; derivation of association schemata for models in the model suite; derivation of tracers for coherence maintenance; rule-based transformation of models; optimization after transformation.
It does not surprise that this approach follows classical four-layer compiler
technologies (lexical and syntactical analysis, derivation of intermediate models,
preparation for optimization, translation, performance management) [
This transformation approach is already state-of-the-art for challenging
applications. Advanced database programming is based on such techniques. Web information
systems development uses such transformations [
The specification and transformation approach has already becoming common
practice for database structuring development. The Higher-Order Entity-Relationship
Modelling (HERM) language [
Modern programming languages provide as much as possible comfort to programmers.
Models are a universal instrument for communication and other human activities. Thought chunks can be presented to those who share a similar culture and understanding without the pressure to be scientifically grounded. Models encapsulate, represent and formulate ideas both as of something comprehended and as a plan. They are more abstract than programs. They can be as precise and appropriate as computer programs. They support understanding, construction of system components, communication, reflection, analysis, quality management, exploration, explanation, etc. From the other side, models can be translated to programs to a certain extent. So, models can be used as higher-level, abstract, and effective programs. Models are however independent of concrete programming languages and environments, i.e. programming language and environment independence is achieved. Models declare what exactly to build. They can be developed to be understandable by all main parties involved in system development. They become general enough and accurate enough. They can be calibrated to the degree of precision that is necessary for high quality.
Model-based programming can then replace classical programming based on compilation and systematic development of models as well on explicit consideration of all model components without hiding intrinsic details and assumptions. Our approach to true fifth generation programming will be extendable to all areas of computer science and engineering beside the chosen four exemplary ones (information system models; horizontally and vertical layered models; adaptable and evolving models; service line models). This paper develops a general framework to true fifth generation programming for everybody.
The framework is based on model suites since the user interface models and the
collaboration models must be an integral part of modelling. Interface and
collaboration treatment generalizes literate programming [
Application engineers and scientists are going to develop and to use models instead of programming in the old style. They will be supported by templates from their application area, can thus concentrate on how to find a correct solution to their problems, can manage the complexity of software intensive systems, will be supported by model-backed reasoning techniques, and will appreciate and properly evaluate the model suite at their level of abstraction. Literate modelling with model suites supports all members of a community of practice (CoP) by reflecting their needs and demands in a given situation and scenario by an appropriate model in the model suite. It becomes thus an effective and efficient means of communication and interaction for users depending on their beliefs, desires, needs, and intentions.
The generalization of the database approach is depicted in Fig. 2. We use a similar form as the experienced one that is displayed in Fig. 1.
Our approach proposes new programming paradigms, develops novel solutions to problem solving, integrates model-based and model-backed work into current approaches, and intents to incubate true fifth generation programming. This new kind of programming enhances human capabilities and could become the kernel of new industrial developments. Models are thus programs of the next generation. 3.2
Our approach is based on model suites as the source, on systematic development of
model suites in a layered approach, on compilers for transformation to programs in
third or fourth generation, and on quality assurance for the model as a program. The
notion of the model suite is based on [
Model development can be layered in a form that is similar to the onion structure in Figures 1 and 2. We use essentially five layers for true fifth generation programming as shown in Figure 3: (1) an internal layer for general initialization, (2) an application definition language layer that includes many additional library packages, (3) the internal supporting and generated layer with its generic and reference libraries, (4) the input model suite that reflects the application and which is essentially the main task for an application engineer, and (5) the generic intermediate output layer, and its delivery layer for multiple output variants depending on the target programming language.
The model suite will be layered into models for initialization, strategic setup as an intrinsic setup, tactic definition as an extrinsic reflection, customization and operationalization as the main program development layer and as operational adaptation, and for model delivery. The complete model suite thus becomes the source for the code of the problem solution, and for the system to be built. Currently, a model is considered to be the final product. Models have their own background that is typically not given explicitly but intrinsically. Currently, methods for developing and utilizing models are accepted as to be given. The intrinsic part of a model and these methods form is called deep sub-model. The deep model is coupled with methodologies and with moulds that govern how to develop and to utilize a model. The deep as well as the general model are starting points for developing the extrinsic or “normal’’ part of a model. Consideration of modelling is often only restricted to normal models similar to normal science. Model suites integrate however these model kinds. The main obstacle why model-driven development and of conceptual-model programming has not yet succeed is the non-consideration of the deep model and of modelling moulds. 4
We envision that true fifth generation programming can be based on development of
high-level program descriptions that can be mapped to third-generation or
fourthgeneration programs. These programs may then be directly executed within the
corresponding environment. This approach has already been the essential idea and its
generalization behind a system for translation of domain-specific languages in the 80ies.
The DEPOT-MS (DrEsdner PrOgrammTransformation) [
A second source for true fifth generation programming is literate programming [
The developed framework, its theoretical underpinning and the realization approach is novel, targets at new programming styles, supports programmers from applications without requiring from them a deep program language knowledge and skills, and is going to overcome current limitations of programming. Layering is one of the great success stories in computer engineering. Already early languages such as COBOL used layered programs (division-section-paragraph-sentence-statementcommand; ICCO: initialize-configuration-content_enhancement-operationalisation; environment-declaration-program). Our approach continues and generalizes this approach and will be thus the basis for true fifth generation programming.
A model in the model suite is used for different purposes such as communication, documentation, conceptualization, construction, analysis, design, explanation, and modernization. The model suite can be used as a program of next generation and will be mapped to programs in host languages of fourth or third generation. Models will become programs of true fifth generation programming.
Models delivered include informative and representation models as well as the compilation of the model suite to programs in host languages. Models will thus become executable while being as precise and accurate as appropriate for the given problem case, explainable and understandable to developers and users within their tasks and focus, changeable and adaptable at different layers, validateable and verifiable, and maintainable.