What Is A 'Fourth-Generation Programming Language' And Why Should I care?
If you've been evaluating construction management software (or other business management software) recently, you've probably encountered terms like "4th-generation programming language" and "4GL." And maybe you've asked yourself, "What in the world is a 4GL . . . and what's a programming language?" Or the most important question, "Why should I care, anyway?"
The answer to "Why should I care?" is simple: you should know enough to insure that you choose the right construction management software to fit your specific application. The typical construction company financial manager really doesn't need to be familiar with the technical details and jargon of computer software programming languages. . . but he or she does need to be sufficiently knowledgeable about the various languages to ensure that the software program does the job for which it was purchased.
Conventional wisdom used to be that the user should only look at what a software package does - screens, reports, and processing logic - and not be concerned with how the system actually does its work. However, the revised school of thought is that inquiring into the language in which a software package is written is like looking under the hood of a truck to see what type of engine it has. Both a diesel and a gasoline engine will work, but the type of engine can have important ramifications; one type might last longer or be more suitable for a given application than another.
With that in mind, here's a primer about software programming languages - and how they relate to construction industry applications.
The History of Programming Languages
Every software package is written using a programming language; a 4GL (fourth-generation software programming language) is just one type of language. It's the latest generation of languages, which began with 1 GL (first-generation language) in the 1950s.
The First Generation
Inside its electronic "brain," a computer only understands two electronic states: "on" and "off." These are normally represented symbolically as 1's and 0's. These 1's and 0's are used to create special codes which represent the various instructions which the computer understands. All computer programs must be translated into this "machine" language before the computer can run them.
When digital computers were first invented in the early 1 950s, computer "programs" had to be written this way - using 1's and 0's - and were entered into the computer by placing wires on circuit boards. Each set of numbers told the computer to do one machine-level instruction (e.g., move the number in storage location 1 to storage location 2). Something as simple as multiplying two numbers together took a whole series of instructions. This "machine" language was the first generation of programming languages.
The Second Generation
As you might suspect, this process was tedious and inefficient and it didn't take long for someone to figure out a better way The first step was to replace the 1's and 0's with abbreviated words, each of which represented one machine instruction. The program would then be "assembled" or translated into the correct sequence of 1's and 0's. This "assembler" language made programming much easier and faster.
Even though the mnemonic codes (e.g., "MOV A, M" or "INX H") look quite cryptic to non-programmers, it was a quantum leap over the unreadable machine language. Note that both the assembler and machine languages still took the same number of lines, but the assembler language was much more intelligible to the trained programmer.
Machine assembler languages thus became the second generation of programming languages. Assembler language was in wide use by the late 1 950s and continued in very heavy use until the late 1 960s. Today, some programs are still written in assembler language.
The Third Generation
In 1959, a new programming language called COBOL was invented, and with it, a third generation of programming languages. COBOL incorporated a revolutionary concept: the programmer could write one COBOL instruction (e.g., multiply two numbers together), and the COBOL "compiler" (itself a computer program written in assembler language) would translate this instruction into the appropriate machine level instructions. In other words, the programmer could tell the computer what he or she wanted done in COBOL and the COBOL language would tell the computer exactly how to do it.
Other 3GL languages were developed around the same time. FORTRAN (short for formula translation) was invented for scientific number-crunching applications. BASIC was intended initially to teach students how to program. RPG (for report generation) became a mainstay on IBM mini-computers. These languages all included the ability to generate multiple machine instructions with one language statement.
GL's greatly reduced the number of lines of programming required to accomplish a given amount of work and, consequently, programmer productivity made another quantum leap. 3GL's were the dominant method of writing business and other types of software from the late 1 960s until very recently. When most people think of programming, they are thinking of third-generation languages.
The Fourth Generation
In the 1970s, plummeting computer hardware costs brought computer systems within reach of many smaller companies. Industry-specific applications - such as job management software designed for the construction industry - began to appear. The PC revolution in the 1 980s placed computers on tens of millions of business desktops, encompassing the complete range of businesses from the largest Fortune 500 companies to small construction companies. These users quickly developed enough "hands-on" knowledge of computers to be able to see the potential for what the right software could do for their businesses.
This caused the software market to explode. Not only did these users want more software to address more functions, they wanted software which solved their specific business problems. Instead of a general accounting program, for example, they needed software which addressed specific needs in their particular industry - including, of course, the construction industry.
Whereas a few years earlier, construction company financial managers were happy if the system printed checks and maintained basic bookkeeping information, now they wanted the system to track detailed job management data and help project managers. They had worked with sophisticated yet easy-to-use mass-marketed software - such as word-processing or spreadsheet programs - and they wanted the same degree of "user friendliness" in their financial management systems.
In short, users demanded easy-to-use, highly-functional software specifically tailored to their needs. This created an enormous opportunity and a major problem. If their needs could be met, businesses were willing to pay for it. Good software was (and continues to be) one of the best investments any business could make. The problem, however, was how to produce this increasingly complex software quickly, efficiently, and reliably. The answer, as seen by many: programming languages that allowed programmers to produce high-quality applications in substantially less time than the existing languages. Thus, the birth of the 4GL.
4GL vs. 3GL
Unlike most 3GL's, which were developed by academicians, 4GL's were developed by businesses based upon market requirements. For this reason, there is no formal definition of a 4GL, other than it should offer an order of magnitude (i.e., about 10:1) improvement in programmer productivity.
Since this is virtually impossible to quantify in an objective manner, the definition is largely determined by the marketplace. In other words, there is a family of products that everyone agrees are 4GL's, so any product which offers comparable functionality is considered a 4GL. Despite this lack of a formal definition, there are characteristics which most 4GL's share and which distinguish them from 3GL's.
3GL's are general-purpose languages. Some might be somewhat specialized. COBOL, for example, was originally designed for business programming (i.e., record management), whereas FORTRAN was designed for complex calculations. However, "C", PASCAL, PL/1, BASIC, and other major languages are completely general purpose and can be used to write almost any type of program. Applications written in "C" and other 3GL's include word-processing programs, spreadsheet programs, operating system programs, as well as business accounting programs.
4GL's on the other hand, are special-purpose languages designed for applications - such as accounting - which focus on data management. For example, virtually every 4GL includes a central data "dictionary" which greatly simplifies this type of programming. (A 4GL would not be used to write systems programs, spreadsheet programs, or scientific programs.) This specialization allows 4GL manufacturers to optimize their 4GL's for data-management applications.
User Interface vs. System Interface
Every computer program interacts with a user. For example, the user may enter information, edit information, issue a command, move to another field, etc. The program, in turn, issues prompts or instructions and reacts to what the user enters. The details of how this interaction occurs is called the user interface. Similarly, a computer program communicates with the system hardware (the system interface). For example, when the user requests that something be printed, the program has to actually tell the system what to print, on which printer, etc.
3GL's and 4GL's differ in the way that the user interface and system interface are programmed. With a 3GL, the programmer is given the basic tools needed to build the user and system interfaces. The good news: the programmer has a wide latitude in designing exactly the interface which he or she wants. The bad news: this takes time, and must be written to fit a specific operating environment (e.g., DOS or UNIX).
With a 4GL, the manufacturer provides a standard, highly functional user and system interface; all applications written using the 4GL automatically incorporate these "built-in" interfaces. This relieves the application programmer from having to develop and maintain this aspect of the application program - but it also gives the programmer less control over the interface.
The "Right" Software Depends upon the Application
The comparison of 4GL vs. 3GL is not a case of one type of language being superior to another. Instead, the suitability of a particular type of language will depend upon the nature of the specific application and the priorities of the application developer. Consider two real-life examples:
Example A is a desk-top publishing program. An important feature of this program is a unique way of using the keyboard or mouse to move graphic images around the page. This requires the programmer to have detailed control over the system hardware. The application is PC-based and it is not important for it to run on other types of computers. Moreover, the application does not need to be tailored to individual users' needs. These factors all point to using a 3GL. The 3GL allows the programmer to control in detail the way the keyboard is used. That the software will only run on PC's and will be more difficult to customize is not critical in this case.
Contrast this with Example B, a developer of an accounting application. For this company, the ability to run on various types of systems and the ability to make custom changes to meet the unique requirements of a customer are very important priorities. As long as the user interface is friendly and powerful, the developer doesn't need detailed control - and in fact would prefer not to have to worry about these details.
These factors would point toward using a 4GL. This will provide the highest possible degree of machine independence and will simplify the problem of managing custom changes. The fact that the programmer does not control the user interface is not a problem - it actually streamlines the programming process.
In brief, 3GL is ideal for standardized applications, like spreadsheets; 4GL, on the other hand is tailor-made (literally) for specialized applications like accounting programs. These examples illustrate an important point: because they have different strengths and weaknesses, 3GL's and 4GL's will continue to coexist for the foreseeable future.
Benefits and Limitations of the 4GL Approach
How does all of this affect the application user? Users don't directly decide whether an application should be 4GL- or 3GL-based any more than truck customers decide whether a diesel or gas engine should be used. The real test in both cases is how the end products perform. If 4GL-based software can deliver real benefits to users' competitive pressures will cause more 4GL-based applications to be written. In applications where the limitations of 4GL's outweigh the benefits, this will not be the case.
With this in mind, let's look at the benefits and limitations of using a 4GL-based application. (I've chosen 4GL as the "comparison point" because it represents the latest develop- ment in programming languages.)
4GL Benefits
Better fit with unique and changing business requirements. Because a 4GL makes programmers more productive, new features and functions can be added with less development time in a 4GL-based application. Also, since 4GL's simplify program maintenance, it is easier to offer cost-effective custom tailoring of a 4GL-based application.
Machine and system independence. An application written in a 4GL should run, without modification, on any computer system which is supported by the 4GL manufacturer. If your company decides to change computer systems - e.g., replace an old mini-computer system with a PC-based network - you can do this without changing your application software.
Access to new system technology. Since most of the systems interface work is done by the 4GL and not by the application, once a 4GL manufacturer develops a version of the 4GL for a new system - such as Windows NT - the application developer can make this available to users with little or no conversion work.
Longer useful life. Businesses usually change financial management software because the software no longer meets the company's needs or because the software does not run on up-to-date computer hardware. The benefits listed above work together to avoid these problems and, thereby, prolong the useful life of a 4GL-based package
4GL Limitations
Increased System Resources. Many 4GL;s require the computer to do more work to store and retrieve information than a 3GL. This can require a faster computer (e.g., a 486 processor instead of a 286) to achieve acceptable system performance. As 4GL's have improved and computers have gotten faster, this has become less of a problem.
Dependence Upon 4GL Manufacturer. Since most 4GL's are proprietary, an application written in one 4GL cannot easily be converted to another. If a 4GL manufacturer were to go out of business and discontinue support of the 4GL, it could leave developers and users in a bad position. The best safeguard against this possibility is to make sure the 4GL manufacturer is solid and has a large installed base. (At the time of this writing, no major 4GL has become obsolete.)
Software Cost. Most 4GL manufacturers require users to purchase "run time" licenses in order to use any software written in the 4GL. This can add somewhat to the cost of an applica- tion. The less expensive the application, the more likely this is to be a significant factor.
Some Advice
As the "new kid on the block," 4GL understandably is not as familiar to construction company financial managers as other programming languages. Thus, a financial manager may not have the information sources available - including word of mouth - that will give him or her good, objective information about 4GL.
A word of caution: 4GL is becoming a popular "buzzword" in the software industry. As with other buzzwords, vendors will sometimes go to great lengths to be able to mention the term 4GL, and it may not be used consistently or correctly. Some simple questions can help the construction company financial manager penetrate the fog
Who is the manufacturer of the 4GL? This will help you determine if the 4GL manufacturer is a major player or a startup.
Is the application written 100% in the 4GL environment or is it written partially in a 3GL? Some application vendors claim to be 4GL-based, but a portion - or even most - of their application is actually written in a 3GL language. Generally speaking, you won't get most of the benefit of a 4GL unless the application is written entirely in the 4GL.
How long has the application developer been using this 4GL? This will tell you whether the vendor is new to the 4GL world or has a lot of "real-world" experience. There is no substitute for talking to end users who have used the software over a period of time.
Can the vendor demonstrate that its users benefit from the 4GL technology? For example, does the software run on multiple systems? Does the vendor have a track record of making substantial improvements to the software on a regular basis? Can it make custom changes, if needed, to accommodate a company's unique requirements? (After all, what good is it to use the latest software technology if the benefits are not passed along to the end user?)
Conclusion
Computer programming languages are the tools used to build applications. There is no right choice for every situation - the choice of the tool depends upon the nature of the job at hand. Assembler language is still used today in certain select situations. 3GL's will continue to be used for the foreseeable future to write many types of software. And 4GL's - the new kid on the block - are here to stay and poised for increasing popularity.
The proliferation of PCs has made an increasing number of business people realize that computers are just like any other business equipment. One doesn't have to be an expert on computer software (thank goodness!) to evaluate and purchase software any more than one has to be an automotive engineer to purchase a truck. However, knowing a little bit about different types of engines - or computer languages - can help the financial manager make a more informed decision. [BP]
Mark Dexter Mark Dexter, CPA, MBA, is President of Dexter & Chaney Inc., a Seattle-based supplier of advanced financial management software for construction contractors. Dexter & Chaney, which serves a national clientele, was formed in 1981.
Mark is an active member of the Associated General Contractors of Washington and a frequent guest speaker at construction industry seminars about financial management software for the construction industry.
Prior to founding Dexter & Chaney with partner John Chaney, Mark was a senior consultant with the Seattle office of Arthur Andersen. He earned his MBA from the Wharton School of Business, University of Pennsylvania (1978) and his BA from Stanford University (1976).
Reproduced by permission from: CFMA Building Profits September/October 1993
Back to Headline News