In software development there is usually a database system used in addition to a programming language. The database system allows data-persistence (i.e. the data remain stored even if the computer has been turned off and the main memory has been cleared). If the programming language allows a short notation (= few lines of code) and the development environment fosters this, the actual programming effort is going to be low because only little code has to be written. Examples for such programming languages are: Many languages with "4GL" in the name, Lotus Notes Macro Language (in the case of lotus notes the entire development environment has been integrated with the programming language and the code dispersion works with the same technique as data distribution via replication). Counter-examples are the so called "Third generation languages": The language C and all derivatives (e.g. C++, C#, Java) as well as Basic and all derivatives (Visual Basic, Lotusscript). If the programming language is well integrated in the development environment, there's an additional speedup in programming. For example: Lotus Domino Designer. In this case there is also the code-administration and code-distribution integrated into the development environment and into the code containers.
When developing typical database applications the following work has to be done:
- Definition of the phys. database scheme (data type, tables, access structures)
- Definition of input and ouput masks
- Programming of printer output lists
- Computation of values on the basis of entered/saved values
- Database administration: Optimization of memory requirements and access structures
- Definition of access authorization and if necessary the setting up of user administration
Modern tools simplify A massively through integration into B for example. They implement C by equating the definition of the screen-output with the definition of the printer-output. Even E can widely be automated in order that the effort will be additionally reduced. An example for such a system is Lotus Notes.
Experience shows that the effort in a software-developing-project is distributed as follows:
- Analysis 10-30%
- Design 10-30%
- Programming 10-20%
- Testing 10-30%
- Training 10-30%
These phases will typically be run through sequentially. Here comes the idea to proceed differently already in the Analysis and Design Phase as well in the Test and Training Phase. One way to do it is "Prototyping".
The participants share among them the roles of developer and customer. In a development project there is on one hand the amount of work in hours or man days of developers and customer and on the other hand the elapsed time (e.g. in days or weeks). Both shall be kept low. Small improvements are to be implemented immediately such that the development goes ahead rapidly. The course of action on prototyping corresponds with following steps:
- Through written requirements specifications we fix what the software has to be able to. The requirements specifications including a raw design of the masks with their fields and a quantity structure (e.g. how many per year). If there is no time to create requirements specification, existing paper and electronic forms have to be consulted.
- Several persons form customer side, which have knowledge about the subject, have to be available to the developers to answer questions and to make decisions and select from proposed design alternatives.
- The developer implements a prototype 0.8 which contains the fundamental functions.
- The prototype 0.8 will be presented to the customer and discussed on the occasion of a common meeting. Improvements will partially be implemented and tested immediately (if the tool allows it) or itemized as action item for later implementation.
- For all the improvements, which were not immediately implemented, the implementation effort will be estimated by the developer and presented to the customer.
- The customer decides whether all or only some of the improvements should be implemented, according to budget and cost and informs the developer.
- The developers implement the desired improvements. Prototype 0.9 emerges.
- Another meeting takes place on which the prototype 0.9 will be presented and discussed. Again some improvements will be implemented immediately others noted.
- Steps 5, 6, 7, 8 will be repeated. Version 1.0 and later possibly 1.1 and 1.2 will be developed. Instead of a presentation a test run (the users test) or a common test workshop (customer/user + developer together) may take place.
- Developers and customer work closely together in contrast to the classic method, where the developer programs in their office, far away from the user.
- The end product is very close to the needs of the customer because developer and customer approach the final product in several iterations (classical method: only one iteration).
- Since small improvements will be implemented directly, the goal will be accomplished faster.
- The programming effort is smaller (if the used languages facilitates this).
- The development tool has to support short notations and automate tasks like compilation and code distribution as much as possible.
- The developers have to know the method and apply it correctly.
- The Customer has to assist and endorse the method.
Summary: If language and development environment match with the method and the developers are qualified and prepared and the customer is also prepared accordingly, user friendly applications will be developed faster and with less effort in comparison to conventional development tools and methods.
Man spricht in diesem Zusammenhang auch von Rapid Application Development (RAD).
The software engineers of ATEGRA have developed a new model: HR Solutions read more
ATEGRA offers you tailor-made software solutions for idea management read more
Solutions for the handling of e-mail and other electronic documents read more
