Fourth Generation Techniques To 4G Approaches Information Technology Essay

The Fourth Generation Technique (4GT) is based on NPL that is the Non-Procedural Language techniques. Depending upon the specifications made, the 4GT approaches uses various tools for the automatic generation of source codes.

Spiral Model

The spiral model, also identified as the spiral lifecycle model, is a systems development lifecycle model used in information technology. This model of development merges the features of the prototyping model and the waterfall model. The spiral model is preferred for large, expensive, and complicated projects.

Advantage of Spiral Model

This model is an example of evolutionary model and combines the features of the prototyping model and the waterfall model.

Estimates (i.e. Budget, schedule, etc.) become more realistic as work progresses, because important issues are discovered earlier.

Software engineers can get their hands in and start working on a project earlier.

Prototyping is used as a risk reduction mechanism

After final iteration, all risks are resolved and the “requirements” are ready for development.

Disadvantage of Spiral Model

The spiral model is intended for large, expensive and complicated projects.

Highly customized limiting re-usability.

Risk of not meeting budget or schedule.

Requires considerable expertise in risk evaluation and reduction.

Complex, relatively difficult to follow  strictly

By comparing each Life cycle I would like to take the Fourth Generation (4GT) to develop the software. The 4GT has a number of query language, reports writers, program writers and application generators and also has the ability to perform high-end object oriented languages. Therefor by using the 4GT can save a lot of software specific coding and allows rapid prototype development. As I mention earlier the 4GT is based on the Non-Procedural Language (NPL) techniques. The Fourth Generation applications can be Modifiable by Design, which means they are designed from the beginning to accommodate change. They are easily modifiable, either by the developer, the customer, or by the Fourth Generation Authorized reseller to user specifications. The Fourth Generation Technique (4GT) is usually successful in implementing smaller applications as we can easily switch from the requirement analysis phase to the implementation phase. Prototypes of any applications can be easily developed with the help of the 4GT approach. This prototype helps the clients to give a rough idea of how the system will look when it is done. The 4GT model is very useful approach in small projects but it is not a dominant approach for large software development.

There are some tools which use in the 4GT paradigm, these tools supports the software development.

Nonprocedural languages for database query

Report generation

Data manipulation

Screen interaction and definition

Code generation

High level graphics capability

The process of 4GT

Gathering

Requirements

Design strategy

Implementing using a 4GT

Product

The 4GT begins with from “Requirement Gathering” this process go through the customer, the customer go illustrate the requirements. The customer could actually describe the requirements and these would be directly translated into an operational prototype. If the product is a smaller product this process may be possible to move directly from requirements gathering step to implementation using a non-procedural fourth generation language (4GL), for lager products this procedure may little hard, therefor it’s necessary to use the design strategy in 4GT.When it comes to large projects, the design phase it is crucial to avoid poor quality, poor maintainability. To transform a 4GL implementation into a product, the developer must conduct through testing, develop meaningful documentation, and perform all other solution integration activities. The 4GT developed software must be built in a manner that enables maintenance to be performed expeditiously. There are some merits to summarize the current features of 4GT approach. In the 4GL implementation the code can be generated based on some specification. The 4GT developed software must be built in a manner that enables maintenance to be performed expeditiously. There are some merits to summarize the current features of 4GT approach. The use of 4GT is a viable approach for many different application areas coupled with computer- aided software engineering tools and code generators, 4GT offers a credible solution to many software problem.

Benefits of the 4GT

Flexible.

The Fourth Generation applications are Modifiable by Design, which means they are designed from the beginning to accommodate change. They are easily modifiable, either by you, the customer, or by your Fourth Generation Authorized reseller to your specifications.

Scalable

The Fourth Generation applications are Modifiable by Design, which means they are designed from the beginning to accommodate change.

They are easily modifiable, either by you, the customer, or by your Fourth Generation Authorized reseller to your specifications.

Total Data Access

Your data represents your company’s greatest single asset. The worth of that asset, however, is directly related to your ability to record it and access it.

Fourth Generation offers the most comprehensive and flexible data access available. From powerful on-screen queries to wide open access to the latest data retrieval tools

Graphical Data Access

Keeping Up With Technology

Fourth Generation is built on a foundation of Industry Standards and components from leading vendors.

This allows you the greatest flexibility when it comes to integrating new technologies and third party products. It also affords you the peace of mind to know you won’t be left behind.

Because of above reason I think the most suitable life cycle is the 4GT life cycle to develop the library system.

For this restaurant to develop a computerized information system for its business operations, I will be using the Fourth Generation Techniques (4GT) process model as the life cycle suitable for this development process. Details of Fourth Generation Techniques (4GT) and the justification for using 4GT is given below.

Fourth Generation Techniques (4GT)

The Fourth Generation Technique (4GT) is based on NPL that is the Non-Procedural Language techniques. Depending upon the specifications made the 4GT move towards uses various tools for the automatic generation of source codes. It is the very important tool which make use of the non-procedural language for Report generation, Database query, Manipulation of data, Interaction of screen, Definition, Generation of code, Spread Sheet capabilities, High level graphical capacity etc.

Like any other models used, the 4GT approach requires the requirement analysis step. Once the requirement analysis is done upto the expectations, its translation into the operational prototype begins. The most important phase in the 4GT approach is the customer developer approach, all the major decisions regarding the implementations, costs and functioning of the system is taken in this phase.

The Fourth Generation Technique (4GT) is usually successful in implementing smaller applications as we can easily switch from the requirement analysis phase to the implementation phase. Prototypes of any applications can be easily developed with the help of the 4GT approach. This prototype helps the clients to give a rough idea of how the system will look when it is done. The 4GT model is very useful approach in small projects but it is not a dominant approach for large software development.

A software development background that supports the 4GT paradigm includes some or all of the following tools:

·       Nonprocedural languages for database query

·       Report generation

·       Data manipulation

·       Screen interaction and definition

·       Code generation

·       High level graphics capability

4GT begins with a requirement-gathering stage. The customer would illustrate requirements and these would be directly converted into an unworkable operational prototype. For small applications, it may be possible to move directly from requirements gathering step to implementation using a non-procedural fourth generation language (4GL), however for large application it is necessary to develop a design strategy for the system even if a 4GL is to be used. Implementation using a 4GT enables the software developer to represent desired result in a manner that leads to automatic generation of code to create those results, obviously, data structure with relevant information must exist and be readily accessible by the 4GL. To transform a 4GL implementation into a product, the developer must conduct through testing, develop meaningful documentation, and perform all other solution integration activities. The 4GT developed software must be built in a manner that enables maintenance to be performed expeditiously. There are some merits to summarize the current features of 4GT approach. The use of 4GT is a viable approach for many different application areas coupled with computer- aided software engineering tools and code generators, 4GT offers a credible solution to many software problem. Data collected from companies that use 4Gt indicates that the time required to produce software is greatly reduced for small and intermediate application is also reduced. However the use of 4GT for large software development efforts demands as much or more analysis design and testing to achieve substantial timesaving that result from the elimination of coding.

Requirement Gathering

Design Strategy

Implementing using a 4GL

Product

 Fourth Generation techniques

Benefits of Fourth Generation Techniques (4GT)

·       The use of 4GT is a feasible approach for a lot of different application areas. Coupled with computer-aided software engineering (CASE) tools and code generators, 4GT offers a convincing clarification to many software problems.

·       Data collectors from organizations that use 4GT indicates that time required to produce software are greatly reduced for small and middle applications and that the amount of design and analysis for small applications is also reduced.

·       However, the use of 4GT for large software development efforts demands as much or more analysis, design and testing (software engineering activities) to achieve substantial time saving that can be achieved through the elimination of code.

 Justification for using Fourth Generation Techniques (4GT)

·       Fourth generation techniques are used because a restaurant system is not complex and also the restaurant have been there for the last two decades and the customer is well aware of the requirements therefore there is no need of deep analysis about the system.

·       Since the customer is aware of the system there is no need of a prototype showing a working model of the proposed system.

·       There are many restaurant systems around the world and they are basically using a common systems therefore there is reusable code that can be used for the restaurant by making less amendments to the code.

·       Fourth generation techniques combine both procedural and non procedural features in to the method of development.

·       The report feature that can be created using 4GT can be used by the restaurant management for making decisions about the business.

The term fourth generation technique (4GT) encompasses a broad array of software tools that have one thing in common: each enables the software engineer to specify some characteristics of software at a high level. The tool then automatically generates the source code based on the developer’s specification. The 4GT paradigm for software engineer focuses on the ability to specify software using specialized language forms or a graphic notation that describes the problems to be solved in terms that the customers can understand.

Currently, a software designing environment that supports the 4GT paradigm include some or all the following tools: non procedural languages for database query, report generation, code generation, data manipulation, high level graphics capability, spreadsheet capability and automated generation of HTML and similar languages used for website creation using advanced software tools.

Like other paradigms, 4GT begins with a requirements gathering step. Ideally, the customer would describe requirements and these would be directly translated into an operational prototype. But this is unworkable. The customer may be unsure of what is required, may be ambiguous in specifying facts that are known, and may be unable or unwilling to specify information in a manner that a 4GT tool may consume. For this reason, the customer/developer dialog described for other process models remains an essential part of the 4GT approach.

For some applications, it may be possible to move directly from the gathering step to the implementation phase using a non procedural fourth generation language (4GL) or a model composed of a network of graphical icons. However, for larger efforts, it is necessary to develop a design strategy for the system, even if a 4GT is to be used. The use of 4GT without design will cause difficulties like poor quality, poor maintainability, poor customer acceptance etc. that have been encountered when designing a software project using conventional approaches.

Implementation using a 4GL enables the software developer to represent the desired results in a manner that leads to automatic generation of code to create those results. Obviously, a data structure with relevant information must exist and be readily accessible by the 4GL.

To transform a 4GT implementation into a product, the developer must conduct thorough testing, develop meaningful documentation, and perform all other solution integration activities that are required in other software engineering paradigms. In addition the 4GT designed software must be built in a manner that enables maintenance to be performed expeditiously.

Like all other software designing paradigms, the 4GT model has advantages and disadvantages. Proponents claims dramatic reduction in software designing time and greatly improved productivity for people who built software. Opponents claim that current 4GT tools are not all that much easier to use than programming languages, that the resultant source code produced by such tools is “insufficient”, and that the maintainability of large software systems designed using 4GT is open to question.

Did you saw her photos?