70 TECHNOLOGY

transorganizational ISs, which take two main forms: those that involve accepting and reporting in-
formation from and to other businesses (B2B electronic commerce) and those that involve accepting
and reporting information from and to consumers (B2C electronic commerce). As companions to
transorganizational ISs, many examples of Web-oriented decision support systems exist (Holsapple
et al. 2000).
1.3. Overview of Information System Development and Tools
Given an application domain and a class of potential users, we are confronted with the problem of
how to create a useful information system. The act of creation spans such activities as analysis,
design, and implementation. System analysis is concerned with determining what the potential users
want the system to do. System design involves transforming analysis results into a plan for achieving
those results. Implementation consists of carrying out the plan, transforming the design into a working
information system.
IS implementation may involve software tools such as programming-language compilers and
database management software. Or it may involve configuring off-the-shelf software packages. The
activity of design can be strongly influenced by what tools are to be used for implementation. Both
the analysis and design activities can themselves be supported by tools such as data flow diagrams,
data dictionaries, HIPO (hierarchical input, process, output) charts, structure charts, and tools for
computer-assisted software engineering (CASE).
In the early days of IS development, the principal software tool used by developers was a pro-
gramming language with its attendant compiler or interpreter. This tool, together with text-editing
software, was used to specify all aspects of an information system’s behavior in terms of programs.
When executed, these programs governed the overall flow of the information system’s actions. They
accomplished information storage and processing tasks. They also accomplished user interaction
tasks, including the interpretation of user requests and production of reports for users. Section 2
provides an overview of programming, accompanied by highlights of two languages widely used for
IS implementation: Visual Basic and C⫹⫹.
Although programming is a valuable way for developers to specify the flow of control (i.e., what
should happen and when) in an information system’s behavior, its use for specifying the system’s
data representation and processing behaviors has steadily diminished in concert with the proliferation
of database management tools. Today, database management systems are a cornerstone of information
system development. Most popular among the various approaches to database management is the
relational, which is described in Section 3. In addition to packaging these as separate tools from
conventional (so-called third-generation) languages such as COBOL, C, and FORTRAN, various
efforts have been made to integrate database management and programming facilities into single
facility. The resultant tools are examples of fourth-generation languages.
Programming and database management tools can be used in implementing ISs in any of the four
classes discussed in Section 2. There is great variation in off-the-shelf packages available for IS
implementation both within and across the IS classes. Section 2.5 considers prominent Web-based
tools used for implementing transorganizational information systems. Section 3 provides a brief over-
view of database management, which forms the foundation for most information systems today.
Section 4 focuses on tools for the class of enterprise ISs. Finally, Section 5 considers ancillary tools
that can be valuable in the activity of developing information systems. These are examined in the
context of the system development life cycle of analysis, design, implementation, and maintenance.
We will focus on tools often used by IS professionals during the analysis and design phases.

2. PROGRAMMING LANGUAGES
2.1. Overview
This section describes how programming languages may be used to build information systems. First,
a brief historical review of programming languages helps explain how programming tools have be-
come more powerful and easier to use over the years. We characterize today’s modern programming
languages, such as C⫹⫹ and Visual Basic, by considering the advantages and disadvantages of each.
Then we review some basic programming concepts by showing some typical examples from these
languages. Finally, we consider how program development is affected when the World Wide Web is
targeted as a platform. This includes a comparison of Internet programming tools, such as HTML,
Java, and CGI scripting.
2.2. Historical Review
In the earliest days of program development, programmers worked directly with the computer’s own
machine language, using a sequence of binary digits. This process was tedious and error-prone, so
programmers quickly started to develop tools to assist in making programming easier for the humans
involved. The first innovation allowed programmers to use mnemonic codes instead of actual binary
TOOLS FOR BUILDING INFORMATION SYSTEMS 71

digits. These codes, such as LOAD, ADD, and STORE, correspond directly to operations in the
computer’s instruction set but are much easier to remember and use than the sequence of binary
digits that the machines required. A programming tool, called an assembler, translates mnemonics
into machine codes for the computer to execute. This extremely low-level approach to programming
is hence referred to as assembly language programming. It forces the programmer to think in very
small steps because the operations supported by most computers (called instruction sets) are very
simple tasks, such as reading from a memory location or adding two numbers. A greater problem
with this approach is that each computer architecture has its own assembly language, due to differ-
ences in each CPU’s instruction set. This meant that early programmers had to recreate entire infor-
mation systems from scratch each time they needed to move a program from one computer to another
that had a different architecture.
The next major innovation in computer programming was the introduction of high-level languages
in the late 1950s. These languages, such as COBOL and FORTRAN, allow a programmer to think
in terms of larger, more complex steps than the computer’s instructions set allows. In addition, these
languages were designed to be portable from machine to machine without regard to the underlying
computer architecture. A tool called a compiler translates the high-level statements into machine
instructions for the computer to execute. The compiler’s job is more complex than an assembler’s
simple task of one-to-one translation. As a result, the machine code that is generated is often less
efficient than that produced by a well-trained assembly programmer. For this reason, programming
in assembly language is still done today when execution time is absolutely critical. The cost of
developing and maintaining high-level code is significantly reduced, however. This is especially
important given another trend in computing, towards cheaper and more powerful hardware and more
expensive and harder-to-find programmers.
As high-level languages became more prevalent, programmers changed to a new development
paradigm, called structured programming. This approach, embodied in languages such as Pascal and
C from the 1970s and 1980s, emphasizes functional decomposition, that is, breaking large program-
ming tasks into smaller and more manageable blocks, called functions. Data used within a function
block is local to that function and may not generally be seen or modified by other blocks of code.
This style of programming is better suited to the development of large-scale information systems
because different functions can be assigned to different members of a large development team. Each
function can be thought of as a black box whose behavior can be described without revealing how
the work is actually being done but rather in terms of input and output. This principle of information
hiding is fundamental to the structured programming approach. Another advantage is code reuse,
achieved by using the more general-purpose functions developed for one project over again in other
systems.
As the information systems being developed became more complex, development with structured
programming languages became increasingly difficult. A new paradigm was required to overcome
the problem, and it arrived in the late 1980s in the form of object-oriented programming (OOP).
This continues to play an important role today. In structured programming, functions are the dominant
element and data are passed around from one function to another, with each function having a
dependency on the structure of the data. If the way the data are represented changes, each function
that manipulates the data must, in turn, be modified. In OOP, data are elevated to the same level of
importance as the functions. The first principle of object-oriented programming is called encapsu-
lation. It involves joining data together with the functions that manipulate that data into an inseparable
unit, usually referred to as a class. A class is a blueprint for actual objects that exist in a program.
For example, the class Clock would describe how all clocks (objects or instances of the class) in a
program will behave. It does not create any clocks; it just describes what one would be like if you
built one, much as an architect’s blueprint describes what a building would look like if you built
one.
The importance of encapsulation is seen when one considers the well-known Year 2000 problem
encountered in many programs written with structured languages, such as COBOL. In many of these
information systems, literally thousands of functions passed dates around as data, with only two
digits reserved for storing the year. When the structure of the data had to be changed to use four
digits for the year, each of these functions had to be changed as well. Of course, each function had
to be identified as having a dependency on the date. In an OOP language, a single class would exist
where the structure of the data representing a date is stored along with the only functions that may
manipulate that data directly. Encapsulation, then, makes it easier to isolate the changes required
when the structure of data must be modified. It strengthens information hiding by making it difficult
to create a data dependency within a function outside a class.
OOP also makes code reuse easier than structured programming allows. In a structured environ-
ment, if you need to perform a task that is similar but not identical to an existing function, you must
create a new function from scratch. You might copy the code from the original function and use it
as a foundation, but the functions will generally be independent. This approach is error-prone and
makes long-term program maintenance difficult. In OOP, one may use a principle called inheritance
72 TECHNOLOGY

to simplify this process. With this approach, an existing class, called the base class or superclass, is
used to create a new class, called the derived class or subclass. This new derived class is like its
parent base class in all respects except what the programmer chooses to make different. Only the
differences are programmed in the new class. Those aspects that remain the same need not be
developed from scratch or even through copying and pasting the parent’s code. This saves time and
reduces errors.
The first OOP languages, such as SmallTalk and Eiffel, were rarely used in real world projects,
however, and were relegated to university research settings. As is often the case with easing system
development and maintenance, program execution speed suffered. With the advent of C⫹⫹, an OOP
hybrid language, however, performance improved dramatically and OOP took off. Soon thereafter,
new development tools appeared that simplified development further. Rapid Application Development
(RAD) tools speed development further by incorporating a more visual development environment for
creating graphical user interface (GUI) programs. These tools rely on wizards and code generators
to create frameworks based on a programmer’s screen layout, which may be easily modified. Ex-
amples include Borland’s Delphi (a visual OOP language based on Pascal), Borland’s C⫹⫹ Builder
(a visual C⫹⫹ language), and Microsoft’s Visual Basic.
2.3. Cⴙⴙ
The C⫹⫹ language was originally developed by Bjarne Stroustrup (Stroustrup 1994) but is now
controlled and standardized by the American National Standards Institute (ANSI). It is an extension
(literally, an increment) of the C programming language. C is well known for the speed of its compiled
executable code, and Stroustrup strove to make C⫹⫹ into a similarly efficient object-oriented language
(see Stroustrup 1994 for a description of the development of the language). Technically, C⫹⫹ is a
hybrid language in that it supports both structured (from C) and object-oriented development. In order
to achieve the speed that earlier OOP languages could not, C⫹⫹ makes some sacrifices to the purity
of the OO model. The tradeoffs required, however, helped make OOP popular with real-world de-
velopers and sparked a revolution in modern program development.
Like C before it, C⫹⫹ is a language with a rich abundance of operators and a large standard
library of code for a programmer’s use. In its current form, C⫹⫹ includes the Standard Template
Library, which offers most of the important data structures and algorithms required for program
development, including stacks, queues, vectors, lists, sets, sorts, and searches (Stroustrup 1997).
Programs written using C⫹⫹’s standard components are easily ported from one platform to another.
The language lacks, however, a standard library of graphics routines for creating a graphical user
interface program under different operating systems. Instead, each compiler vendor tends to offer its
own classes and functions for interacting with a specific operating system’s windowing routines. For
example, Microsoft offers the Microsoft Foundation Classes (MFC) for developing Windows appli-
cations with its compiler, while Borland offers its Object Windows Library (OWL) for the same
purpose. This makes it difficult to port GUI programs from one vendor’s compiler on one operating
system to another vendor’s compiler on another operating system.
A simple example (Main and Savitch 1997) is shown below that declares a basic Clock class. It
is an abstraction of a real-world clock used for telling time.

class Clock {
public:
Clock();
void set time(int hour, int minute, bool morning);
void advance(int minutes);
int get hour() const;
int get minute() const;
bool is morning() const;
private:
int hour 24, // Stores the current hour
minute 24; // Stores the current minute
};

This class is typical of the structure of most classes in C⫹⫹. It is divided into two sections, public
and private. In keeping with information hiding, the data are normally kept private so that others
outside of the class may not examine or modify the values stored. The private data are exclusively
manipulated by the class functions, normally referred to as methods in OOP. The functions are
declared in the public section of the class, so that others may use them. For example, one could ask
a clock object its minute by using its get minute() function. This might be written as in the following
code fragment:

Clock c; // Creates an actual object, c

cout ⬍⬍ ‘‘The minute is ‘‘ ⬍⬍ c.get minute() ;⬍⬍ endl;
TOOLS FOR BUILDING INFORMATION SYSTEMS 73

Of course, this simple class provides a method for modifying the time stored. The public method
set time() is used for this purpose. By forcing the use of this method, the class designer can ensure
that the data are manipulated in accordance with appropriate rules. For example, the set time()
method would not allow the storage of an illegal time value. This could not be guaranteed if the data
were public and directly available for modification. The implementation of this method is shown
below:

void Clock::set time(int hour, int minute, bool morning) {

assert((hour ⬎⫽ 1) && (hour ⬍⫽ 12));
assert((minute ⬎⫽ 0) && (minute ⬍⫽ 59));
minute 24 ⫽ minute;
if ((morning)&&(hour ⫽⫽ 12))
hour 24 ⫽ 0;
else if ((!morning) && (hour ⬍ 12))
hour 24 ⫽ hour ⫹ 12;
else
hour 24 ⫽ hour;}

Note how the values passed to the method are tested via an assert() statement before they are used.
Only if the assertion proves true are the values used; otherwise a runtime error message is produced.
To show an example of inheritance, consider extending the Clock class to create a new class,
CuckooClock. The only difference is that this type of clock has a bird that chirps on the hour. In all
other respects it is identical to a regular clock.

class CuckooClock : public Clock {

public:
bool is cuckooing( ) const;
};

bool CuckooClock::is cuckooing( ) const {

return (get minute( ) ⫽⫽ 0);}

Note, we declare the new CuckooClock class in terms of the existing Clock class. The only methods
we need to describe and implement are those that are new to or different from the base class. Here
there is only one new function, called is cuckooing(), which returns true on the hour. It is important
to understand that CuckooClock is a Clock. In important respects, an instance of CuckooClock can
do anything that a Clock object can do. In fact, the compiler will allow us to send a CuckooClock
object anywhere a Clock object is expected. For example, we might have a function written to
compare two Clock objects to see if one is ‘‘equal to’’ the other.

bool operator ⫽⫽(const Clock& c1, const Clock& c2) {

return ((c1.get hour() ⫽⫽ c2.get hour()) &&
(c1.get minute() ⫽⫽ c2.get minute()) &&
(c1.is morning() ⫽⫽ c2.is morning())); }

We may confidently send a CuckooClock to this function even though it is written explicitly to expect
Clock objects. Because of inheritance, we do not need to write a different version of the function for
each class derived from Clock—CuckooClock is a Clock. This simplifies things considerably for the
programmer. Another interesting note about this code segment is that C⫹⫹ allows us to provide
definitions for most of its built-in operators in the context of a class. This is referred to as operator
overloading, and C⫹⫹ is rare among programming languages in allowing this kind of access to
operators. Here we define a meaning for the equality operator (⫽⫽) for Clock objects.
In summary, C⫹⫹ is a powerful and rich object-oriented programming language. Although widely
recognized as difficult to work with, it offers efficient execution times to programmers that can master
its ways. If you want portable code, you must stick to creating console applications. If this is not a
concern, modern compilers assist in creating GUI applications through wizards, such as in Microsoft’s
Visual C⫹⫹. This is still more difficult to accomplish using C⫹⫹ than a RAD tool such as Visual
Basic, which will be discussed next.

2.4. Visual Basic

Visual Basic (VB) is a programming language and development tool from Microsoft designed pri-
marily for rapidly creating graphical user interface applications for Microsoft’s Windows operating
74 TECHNOLOGY

system. First introduced in 1991, the language is an extension of BASIC, the Beginners’ All-Purpose
Symbolic Instruction Code (Eliason and Malarkey, 1999). BASIC has been in use since John Kemeny
and Thomas Kurta introduced it in 1965 (Brookshear 1999). Over the years, Visual Basic has evolved
more and more towards an object-oriented programming model. In its current version, 6.0, VB pro-
vides programmers with the ability to create their own classes using encapsulation, but it does not
yet support inheritance. It simplifies the creation of Windows applications by making the enormously
complex Windows Application Program Interface (consisting of over 800 functions) available through
easy-to-use objects such as forms, labels, command buttons, and menus (Eliason and Malarkey 1999).
As its name suggests, Visual Basic is a highly visual tool. This implies not only that the devel-
opment environment is GUI-based but also that the tool allows you to design a program’s user
interface by placing components directly onto windows and forms. This significantly reduces devel-
opment time. Figure 1 provides a snapshot of the Visual Basic development environment.
Another feature that makes Visual Basic into a Rapid Application Development tool is that it
supports both interpreted and compiled execution. When VB is used in interpreted mode, the tool
allows the programmer to quickly see the effects of their code changes without a lengthy compilation
directly to machine code. Of course, run-time performance is better when the code is actually com-
piled, and this can be done before distributing the application.
In Visual Basic, objects encapsulate properties, methods, and events. Properties are an object’s
data, such as a label’s caption or a form’s background color. Methods are an object’s functions, as
in C⫹⫹ and other OOP languages. Events are typically user-initiated actions, such as clicking a form’s
button with the mouse or making a selection from a menu, that require a response from the object.
Figure 1 shows some of the properties of the highlighted command button object, Command1. Here
the button’s text is set to ‘‘Press Me’’ via the Caption property. In the code window for the form,
the Click event’s code is displayed for this command button. This is where you would add the code
to respond when the user clicks on the form’s button. The tool only provides the outline for the code,
as seen here. The programmer must add actual VB statements to perform the required action. Visual
Basic does provide many wizards, however, to assist in creating different kinds of applications,
including forms that are connected back to a database. These wizards can significantly reduce de-
velopment time and improve reliability.
The fundamental objects that are important to understand in Visual Basic development are forms
and controls. A form serves as a container for controls. It is the ‘‘canvas’’ upon which the programmer

Figure 1 The Visual Basic Development Environment.

TOOLS FOR BUILDING INFORMATION SYSTEMS 75

‘‘paints’’ the application’s user interface. This is accomplished by placing controls onto the form.
Controls are primarily GUI components such as command buttons, labels, text boxes, and images.
In Figure 1, the standard toolbox of controls is docked on the far left of the screen. These controls
are what the user interacts with when using the application. Each control has appropriate properties
and events associated with it that affect its appearance and behavior. For example, consider the form
shown in Figure 2.
This form shows the ease with which you can create a database-driven application. There are
three controls on this form. At the bottom of the form is a data control. Its properties allow the
programmer to specify a database and table to connect to. In this example, it is attached to a simple
customer database. At the top are two textbox controls, used for displaying and editing textual in-
formation. In this case, these controls are bound to the data control, indicating that their text will be
coming from the associated database table. The data control allows the user to step through each
record in the table by using the left and right arrows. Each time the user advances to another record
from the table, the bound controls update the user’s text to display that customer’s name and address.
In the code fragment below, you can see some of the important properties of these controls.

Begin VB.Data Data1

Caption ⫽ ‘‘Customer’’
Connect ⫽ ‘‘Access’’
DatabaseName ⫽ ‘‘C:\VB Example\custdata’’
DefaultCursorType⫽ 0 ‘DefaultCursor
DefaultType ⫽ 2 ‘UseODBC
Exclusive ⫽ 0 ‘False
ReadOnly ⫽ 0 ‘False
RecordsetType ⫽ 1 ‘Dynaset
RecordSource ⫽ ‘‘Customer’’
End

Begin VB.TextBox Text1

DataField ⫽ ‘‘customer name’’
DataSource ⫽ ‘‘Data1’’
End

Begin VB.TextBox Text2

DataField ⫽ ‘‘street address’’
DataSource ⫽ ‘‘Data1’’
End

In the data control object, Data1, there are several properties to consider. The Connect property
specifies the type of database being attached, here an Access database. The DatabaseName property
specifies the name and location of the database. RecordSource specifies the table or stored query that
will be used by the data control. In this example, we are connecting to the Customer table of the
example database. For the bound text controls, the programmer need only specify the name of the
data control and the field to be used for the text to be displayed. The properties that need to be set
for this are DataSource and DataField, respectively.

Figure 2 Database Example.

76 TECHNOLOGY

As these examples demonstrate, Visual Basic makes it relatively easy to create complex GUI
applications that run exclusively under the Windows operating system. When these programs are
compiled into machine code, the performance of these applications is quite acceptable, although not
yet as fast as typical C⫹⫹ programs. The object-oriented model makes development easier, especially
since most of the properties can be set visually, with the tool itself writing the necessary code.
Unfortunately, VB still does not support inheritance, which limits a programmer’s ability to reuse
code. Recent additions in the language, however, make it easier to target the Internet as an application
platform. By using Active X controls, which run under Windows and within Microsoft’s Internet
Explorer (IE) web browser, and VBScript (a subset of VB that runs in IE), you can create applications
that may be ported to the World Wide Web. Your choice of controls is somewhat limited and the
user must have Microsoft’s own web browser, but in a corporate Intranet environment (where the use
of IE can be ensured) this might be feasible. For other situations a more flexible solution is required.
The next section will explore some of the tools for achieving this.
2.5. Web-Based Programming
Developing applications where the user interface appears in a web browser is an important new skill
for programmers. The tools that enable a programmer to accomplish this type of development include
HTML, Java, CGI, Perl, ColdFusion, ASP, etc.—a veritable cornucopia of new acronyms. This section
explains these terms and shows how these new tools may be used to create web pages that behave
more like traditional software applications.
2.5.1. HTML
The HyperText Markup Language (HTML) is the current language of the World Wide Web. HTML
is a markup language, not a programming language. Very simply, a document is ‘‘marked up’’ to
define its appearance. This involves placing markup tags (or commands) around text and pictures,
sound, and video in a document. The general syntax for HTML tags is:

⬍Tagname [options]⬎your text here⬍ / tagname⬎

These tags indicate how to display portions of the document. Opening tags, along with available
options, are enclosed in ⬍ and ⬎ and closing tags include the / before the tagname. In some instances
both opening and closing tags are required to indicate what parts of the documents the tags should
affect. In other instances no closing tag is required. The contents of the file (including HTML tags
and web page contents) that generates the simple web page shown in Figure 3 are as follows:

⬍html⬎
⬍head⬎
⬍title⬎Tools for Building Information Systems⬍/title⬎
⬍/head⬎
⬍body⬎
⬍center⬎⬍h1⬎Tools for Building Information Systems⬍/h1⬎
by⬍p⬎
Robert L. Barker⬍br⬎Brian L. Dos Santos⬍br⬎Clyde H.

Figure 3 Web Page and HTML Tags.

TOOLS FOR BUILDING INFORMATION SYSTEMS 77

Holsapple⬍br⬎William P. Wagner⬍bR⬎and⬍br⬎Andrew Wright

⬍/center⬎⬍p⬎
Revolutionary changes in computer hardware, accompanied by
an evolution in software and methodology, have hastened a
movement to the information age.
⬍/body⬎
⬍/html⬎

HTML documents may then be processed and displayed using a browser that runs on any number
of computer platforms, from UNIX workstations down to cellular telephones. These documents are
simple text files that can be created with WYSIWYG tools (such as Microsoft’s FrontPage or Net-
scape’s Composer) or even a simple text editor such as the Windows Notepad. HTML relies on tags,
keywords enclosed in angle brackets, like ⬍h1⬎, ⬍b⬎, ⬍li⬎, etc., to specify what type of content
or formatting is intended. HTML standards are controlled by an organization called the World Wide
Web Consortium (W3C), and their website (http: / / www.w3.org / ) has the most accurate and up-to-
date information about HTML.
The latest version of HTML is 4.0 (http: / / www.w3.org / MarkUp / ), and several of today’s brows-
ers support most of its features. In addition, the leading producers of web browsers, Microsoft and
Netscape, frequently include support for proprietary features not specified in the W3C’s version of
HTML. These extensions can make it difficult to create extremely complicated documents that will
work on both browsers. This is especially true for dynamic HTML documents, or documents whose
contents change even after the page is loaded into a browser (Castro, 1999). HTML 4.0 includes
support for Cascading Style Sheets (http: / / www.w3.org / Style / ), which gives page designers easier
control of large and complicated websites. HTML is essentially a system for formatting documents.
It includes both structuring and formatting tags, which makes it difficult to maintain complex web-
sites. The introduction of cascading style sheets allows a designer to separate structuring and for-
matting tags. Formatting tags are maintained in cascading style sheets so that HTML is used only
for structuring documents. Style sheets are very powerful but not as easy to use as basic HTML. The
future, however, lies in Extensible Markup Language (XML) (http: / / www.w3.org / XML / ). XML is
designed to allow groups to create their own markup languages, like HTML, specifically suited to
their needs (Castro, 1999). It is especially important for its ability to put structured data into a text
format. This might make it easy to view and edit a spreadsheet or database via the Web, for example.
In fact, the W3C is rewriting HTML (as XHTML) and its Cascading Style Sheets (as XSL) using
XML (see http: / / www.w3.org / TR / xhtml1 / and http: / / www.w3.org / Style / XSL / ).
HTML, by itself, does not provide the capabilities required for electronic commerce. For e-
commerce, it is necessary to develop applications that are interactive in nature, permitting visitors to
dynamically obtain information they need (e.g., search a product catalog) or complete some task
(e.g., submit an order). Such capabilities typically require that user-provided data be processed in
real time and require interaction with databases. This type of processing may be accomplished via
programming languages such as Perl, Visual Basic, and C⫹⫹. Recently, several tools have emerged
that reduce the need for traditional programming while essentially achieving the same results (e.g.,
ColdFusion and Tango). These capabilities are often achieved via the Common Gateway Interface
(CGI).

2.5.2. CGI
To create truly powerful websites, a programmer must be able to access current data, typically from
a corporate database. For example, commerce sites need to be able to tell a user whether a product
is in stock and record how many items a customer would like to purchase. This cannot be done with
static HTML files. Instead, processing is required on the server-side before the contents of a web
page are delivered to a user’s web browser. One widely used approach is the Common Gateway
Interface (CGI). CGI specifies a common method for allowing Web pages to communicate with
programs running on a Web server.
A typical CGI transaction begins when a user submits a form that he or she has filled out on a
web page. The user may be searching for a book by a certain author at an online bookstore and have
just entered the author’s name on a search page. The HTML used for displaying the form also
specifies where to send the data when the user clicks on the submit button. In this case, the data is
sent to a CGI program for processing. Now the bookstore’s CGI program searches its database of
authors and creates a list of books. In order to return this information to the user, the CGI program
must create a response in HTML. Once the HTML is generated, control may once again be returned
to the web server to deliver the dynamically created web page. CGI programs may be written in
nearly any programming language supported by the operating system but are often written in spe-
cialized scripting languages like Perl.
78 TECHNOLOGY

CGI provides a flexible, but inefficient mechanism for creating dynamic responses to Web queries.
The major problem is that the web server must start a new program for each request, and that incurs
significant overhead processing costs. Several more efficient alternatives are available, such as writing
programs directly to the Web server’s application program interface. These server APIs, such as
Microsoft’s ISAPI and Netscape’s NSAPI, allow more efficient transactions by reducing overhead
through the use of dynamic link libraries, integrated databases, and so on. Writing programs with
the server APIs is not always an easy task, however. Other alternatives include using products like
Allaire’s ColdFusion or Microsoft’s Active Server Pages (ASP).

2.5.3. Java
Java is a programming language from Sun Microsystems that is similar to C / C⫹⫹ in syntax and may
be used for general-purpose applications and, more significantly, for embedding programs in web
pages (Hall 1998). Although Java is an extremely young language, it has gained widespread accep-
tance because of its powerful and easy-to-use features. It is not yet a mature product, however, and
experiences some stability problems as the language continues to evolve.
Java has a lot in common with C⫹⫹, so much so that it is often referred to as ‘‘C⫹⫹ Lite’’ by
experienced programmers. It is an object-oriented programming language that was built from the
ground up, unlike the hybrid C⫹⫹. It is designed to be a cross-platform development tool; in other
words, the code is easy to port from one computer architecture and operating system to another. It
does a better job of this than C⫹⫹ does by including a standard set of classes for creating graphical
user interfaces. This allows a GUI application designed on a Macintosh to be run under Windows or
Linux, for example. Extremely complex interfaces may still require tweaking to achieve complete
interchangeability of the interface, but new additions to the language (the Swing classes) make this
less necessary. Java is widely considered a simpler language to use than C⫹⫹ because it forgoes some
of the more troublesome C⫹⫹ (though powerful) features. For example, Java does not explicitly use
pointers and has automatic memory management, areas where C⫹⫹ programmers often introduce bugs
into their programs. This makes Java much easier to work with and somewhat less error-prone. Java
only supports single inheritance, which means that a derived class may only have a single parent
base class. C⫹⫹ allows the use of the more powerful form, multiple inheritance, which allows several
parents for a derived class. Java does not support templates, which allow C⫹⫹ programmers to create
functions and classes that work for many different types of data without needing to be implemented
separately for each. Java also does not support operator overloading. Like C⫹⫹, however, Java does
have a rich and powerful set of standard libraries. Java’s libraries even include components for
network programming and database access (through JDBC), which standard C⫹⫹ lacks. Even with
all these improvements to C⫹⫹, Java would be a footnote in the annals of programming if it were
not for its web features.
Java allows the creation of specialized applications called applets, which are designed to be run
within a web browser. Most modern web browsers support Java in some form, and Sun offers plug-
ins that provides the most up-to-date language features. Early applets focused on creating more
dynamic web pages through animations and other graphical components easily created in Java but
hard to reproduce in pure HTML. Today, applets are used for delivering entire software applications
via the Web. This has many advantages over a traditional development and distribution model. For
example, programmers do not have to worry about the end-user platform because applets run in a
browser. Users don’t have to worry about applying patches and bug fixes because they always get
the latest version from the Web. Security is an obvious concern for applets because it might be
possible to write a malicious Java applet and place it on a web page for unsuspecting users. Luckily,
the Java community has created a robust and ever-improving security model to prevent these situa-
tions. For example, web browsers generally restrict applets from accessing memory locations outside
their own programs and prevent writing to the user’s hard drive. For trusted applets, such as those
being run from a company’s Intranet, the security restrictions can be relaxed by the end user to allow
more powerful functionality to be included.

2.5.4. ColdFusion
ColdFusion is a tool for easily creating web pages that connect to a database. Developed by Allaire
(http: / / www.allaire.com), ColdFusion is being used in thousands of Web applications by leading
companies, including Reebok, DHL, Casio, and Siemens. The ColdFusion Markup Language (CFML)
allows a user to create Web applications that are interactive and interface with databases. The syntax
of CFML is similar to HTML, which is what makes it relatively easy to use; it makes ColdFusion
appealing to Web designers who do not have a background in programming. ColdFusion encapsulates
in a single tag what might take ten or a hundred lines of code in a CGI or ASP program. This allows
for more rapid development of applications than competing methods provide. However, if a tag does
TOOLS FOR BUILDING INFORMATION SYSTEMS 79

not do exactly what you need it to, then you must either change your application or resort to a
programmatic approach. Although ColdFusion is not a programming language per se, knowledge of
fundamental programming concepts and SQL is essential for sophisticated applications. CFML allows
a user to display output based on the results of a query to a database and update databases based on
user input. In order to use CFML, a ColdFusion Application Server (CFAS) must be installed. CFAS
works in conjunction with a web server. The CFAS can do much more than query / update databases;
it interfaces with many different Internet services to provide the functionality that a website designer
desires. Figure 4 shows how a ColdFusion Application Server interacts with a web server, databases,
and other services it provides.
The following sequence of actions illustrates how ColdFusion functions to produce dynamic
results.

1. A user submits a form via a browser. The form is designed to be processed by a file containing
CFML code. This file must have a ‘‘cfm’’ extension.
2. The web server recognizes the cfm extension and hands the file to the CFAS for processing.
3. The CFAS executes the instructions per the CFML code. This typically results in information
from a database to be included in the web page. In addition, it may interact with other Internet
services, such as other web servers, e-mail, etc.
4. The web page generated by the CFAS is then returned to the web server.
5. The web server sends this page to the browser.

Allaire offers versions that run under Microsoft Windows NT and the Unix-based operating sys-
tems Solaris and HP-UX. ColdFusion programs interface with many different Web server APIs to
provide greater efficiency than traditional CGI programs.

2.5.5. ASP
One of Microsoft’s methods for creating more dynamic web pages is through its web server’s support
of Active Server Pages. ASP lets programmers use the VBScript programming language on the server-
side to create HTML content on-the-fly. Because ASP is built into the Web server, it is more efficient
than other CGI programs. It offers greater flexibility and control than a product like ColdFusion but
requires greater programming knowledge to achieve results.

3. DATABASE MANAGEMENT TOOLS

3.1. DBM Concepts
One of the most important functions that an information system must perform is data management
(i.e., record keeping). Prior to the advent of true database software, computer data management was
characterized by excessive data redundancy (or duplication), large data dependence (or coupling),

Figure 4 ColdFusion Application Server.