Chapter 1. Unix Overview: What You Need to Know to Get Started

We start with the idea of a remote computer that stores your files, to which one connects with a utility such as telnet. All of the necessary Unix commands are introduced. This chapter ends with a comprehensive example that involves creating a directory structure that contains sub-folders, files and programs. We archive and compress it, then transport it to another computer, where we uncompress and unarchive, recovering the original directory structure of folders and files that we started from. Same process used in Apache download and installation.

The web is described from the point of view of a user. Web browsers and servers. Purpose of web servers. NCSA and the Apache web server. Installation. Setting up the home page. Ports. Configuration of Apache.

The most relevant aspects of HTML are reviewed keeping in mind that HTML will be the output of programs in this class. All essential folders and files in the Apache distribution are reviewed and explained, including access and error log files, starting and stopping Apache, and what's involved in setting up possible Apache extensions.

Setting up crontab for automatic restart. Checking and understanding system logs. HTTP transactions are described through a series of experiments involving telnet (in which we, as end-users, act as browsers). Emphasis is on the connectionless nature of the HTTP protocol.

Creating files under Unix. Unix text editors. Perl and the Perl interpreter. Writing the simplest Perl program. Making the file executable. Running the program. Quick overview of Perl: scalars, lists, hash tables, control structures (foreach) and special operators (keys). File access, simple pattern matching and substitution. Presentation is meant to provide a foundation for chapter 7, where we implement a generic CGI processor in Perl (based on Steve Brenner's cgi-lib.pl).

Discovering the cgi-bin directory. Putting this discovery to work. Writing simple CGI scripts that output HTML. MIME types and HTTP response headers. Making the output change on request. Getting data into CGI scripts. The %ENV hash table. Experimenting with HTML forms (your entry level GUI).

CGI is defined as a data format used in conjunction with a set of encoding conventions. A generic CGI processor is developed. Lots of lab experiments help build a thorough understanding.

CPAN, Perl modules, and CGI.pm are introduced. This chapter loosely follows Conway [8] below. The structure of the exposition is chosen such that the pattern developed in this chapter will be used in later chapters (13-JavaScript and 16-Java) in the exact same way, to unify the coverage of object-oriented concepts.

The main difficulty is exposed by starting from a program developed in chapter 5. Several state-maintaining techniques are presented: on the client-side we rely on hidden fields, cookies, on the server side we only mention flat files and DBM files (as we choose to work exclusively with a relational database managament system for all our server-side state-maintaining examples).

The concept of relational databases is described. SQL is introduced. Basic data modeling is covered, and an application completely designed and implemented in MySQL. The purpose now is to build a web front end to this RDBMS application using Perl, CGI.pm and DBI.pm modules, which the chapter accomplishes.

Aspects of security on the web are described, particularly security of transmission against third-parties eavesdroppers. We then set up a secure communication link between server and client (the user) and discuss strategies and implementation techniques used to protect the server against malicious users.

Starting as a CGI script a new server-side paradigm has evolved into what's now called PHP. We install PHP both as a standalone binary and as an Apache module. We briefly describe installing and developing Apache modules. Complete description of PHP follows, aimed at building a working prototype of an e-commerce application (a shopping cart) with a database back-end.

The framework of chapter 8 is used here to describe this language, whose purpose is to extend the browser's functionality. No network connection is necessary, only a browser that supports the language. Emphasis is on JavaScript as a tool enhancing HTML interfaces. The benchmark application (basic shopping cart) is implemented here adding to its GUI the JavaScript capabilities, on the client-side. The interpreter for the language being embedded in the browser, the process is compared with that goes on in the PHP parser (on the server-side) before the answer is sent to the user.

Adding JavaScript to the interface has many benefits, but none of them has anything to do with the layout, or the actual design of the interface. Only the basic functionality is affected or influenced. For professional layout we rely on CSS. Cross-browser compatibility issues are covered. The basic issue here is presentation.

We started on the server side, with Perl and CGI. We then introduced a radically different style of programming on the server-side, PHP. In both cases output is HTML text, sent to the browser. HTML is rendered on the client side, by the browser, and offers some GUI elements, but little interactivity. That supplement is offered by JavaScript, which runs on the client side, using PHP's paradigm (see chapter 15). Now we stay on the client side, with a different paradigm: Java. We look at what it takes to run, install, and write Java applets, and what makes them different from Java standalone applications, and Javascript code.

Keeping the same object-oriented framework of presentation that we started in chapter 8, we take a thorough complete look at the Java programming language. Classes, methods, variables, objects, inheritance, then the relevant APIs: I/O, networking, GUIs, utilities, exceptions, and JDBC. To make it clear why Java is considered powerful we develop a simple web server and a web browser using Java.

Now the circle is complete. We started from the server side and we are now back on the server side. In this chapter we install Tomcat and describe the servlet API. Compare (and contrast) Java servlets with CGI scripts. Discussion on what is needed to hook Tomcat into Apache, as a distinct module.

Develop a chat application with servlets on the server-side, and a Java applet on the client side. Networking is done as in one of the examples in Hunter [30] by developing a special class that is using HTTP to transmit and receive messages. We stress independence of the Java language and the Java computing platform by implementing a version of the chat program as a standalone networked application (using RMI, Remote Method Invocation).

JSP is presented as an alternative to PHP and ASP (which is not covered in this class, but discussed here). We go through a sequence of typical server-side programming examples and while do this we also take the time to describe JSP and to compare and contrast it with PHP, Java servlets and with CGI.

We look at JMF (Java Media Framework) and describe an implementation of a simple videophone. We discuss what it takes to port this simple but useful application to the web. Discussion will focus more on the player side first.

The need for XML is described. The merits of the solution (XML itself) are listed. The specifics are identified. The books by Holzner [38] and McLaughlin [39] are the sources for this chapter. We stress the need for a parser, the feasibility of automatic transformation, and describe a business-to-business application (which is the next logical level of electronic commerce). Lab exercises emphasize the concepts.

We list all the ways in which XML could be beneficial (presentation, portable data format, RPC and networking, configuration) and sketch the design of each of the applications listed. We then finish the implementation of the business-to-business (B2B) application started in the preceding chapter (see www.bestbookbuys.com).

This is an attempt to fit WWW development into the framework developed by James Burke's book [45]. Essentially we look at the past, we summarize what's known, and indicate points of interest in what the plausible, foreseeable future might be.

The overall cutoff scale is as follows:

Percent
0-54	55-59	60-65	66-67	68-69	70-75	76-77	78-79	80-85	86-87	88-89	90-95	96-100
F	D-	D	D+	C-	C	C+	B-	B	B+	A-	A	A+
Grade

Late policy: all assignments need to be turned in on time. We'll help you with that.

One of the early choices for an A348 textbook (in 1996). Somewhat dated, good as a reference in many ways.

This book is to the Internet networking what the Feynman lectures were to Physics (by and large). Outstanding overall presentation.

Useful to jump-start one's interaction with Unix, or as a reference.

Most of Perl programming is system programming like what's presented in this book. One needs to know what's available in terms of automating system administration and management, such as writing a starthttpd script to start/restart/stop the server.

Visual quickstart for those (not few) intimidated by Unix.

The authoritative description of the language, by the author.

A wonderful, general description of the object-oriented aspects of Perl. The book contains three useful cross-language appendices.

Our choice of a textbook in 1997 and 1998. Somewhat dated now, it shines in particular in its chapter 3 (installation of Apache), and in chapter 10 (Javascript). Chapters 1, 2 also serve as good introductory material.

Succint, almost complete, overview of all things webmaster. Cannot be used as a hands-on tutorial in any way, though.

Good description of installation and customization of Apache. It lacks a purpose (or focus) though, although coverage is complete.

Used for Chapter 13 mostly (but not only).

Extremely old, but beautiful book on which our chapter 7 is based.

Case studies in CGI. Reading this book is as refreshing as solving a crossword puzzle, i.e. its makes an excellent complementary reading.

When one needs a CGI module Lincoln's CGI.pm is the de facto standard. This book is the tutorial and reference for the package.

This is a book of the highest quality. First, chapter 1 contains an outstanding overview of the domain. Stein and MacEachern focus on writing Apache modules with Perl thereafter exclusively, so generality is lost (on purpose, since the book is about writing Apache modules). So the first chapter appears as a bonus, eventually. But this first chapter overview alone is worth the price of the book.

Extremely thorough treatment of MySQL and SQL, with many examples. Our one-stop reference for all things RDBMS in this class.

Our reference for DBI.pm this book is even a bit more general than needed, including a few chapters that complement DuBois [16].

Our treatment of PHP is based on this book and Chapter 16 of [10].

Together with the Larson and Stephens reference [20] a great interactive workbook for the lab. Mostly network concepts, that relate to the Comer book [3].

Hands-on activities and multiple-choice exercises on most of the topics covered in Webmaster in a Nutshell [10]. Excellent value, a good model for what a lab manual should look like, except it's only about administration and not as much about programming.

Good reference on the core Java language APIs.

Servlets, RMI, JDBC, not covered in [21].

Very entertaining and complete overview of Java. Especially the part on threads is a work of genius in its extremely simple and straightforward presentation.

Review of accompanying, complementary technologies.

Very good, complete description of RMI. Parts of chapters 18, and 20 rely on concepts covered in this book.

Our treatment of servlets and JSP is based partially on this.

The JSP coverage is based on this and Marty Hall [26].

Updated, enhanced version of [26].

The source for any Java jumpstart. Complete range of excellent examples.

Our treatment of servlets is based on this book. Especially the development of a web chat application using HTTP as a communication protocol between an applet and the server is based on its chapter 10.

Complete Javascript, supporting our coverage of JavaScript in the same way Conway [8] does it for Perl, and (to a certain extent) van der Linden [23] for Java.

Recommended reading for issues, concepts, principles of security.

Essentially a checklist from the once maintainer of the WWW Security FAQ.

Handbook of Unix system administration techniques (should one need them).

An early attempt at summarizing all existing implementation technologies.

Practical examples. Our chapter 14 is based on it.

Same as Livingston and Brown [36], focusing more on Internet Explorer.

Excellent overview of XML on both sides (server and client side), with many hands-on projects. We use it in chapter 21.

This book is focusing on Java tools for XML. It lacks the crisp structure and sparkling organization of Holzner [39] but it impresses through the sheer generosity of an extremely honest exposition. It has a list of potential applications (chapters 9 and up). We use it in our XML chapters (21, 22).

On implementing the simple videophone. This book is not enough, but very useful, and it is well written.

Automatic transformation from one format to another. Used in conjunction with Holzner [38] and Mc Laughlin [39] this and the next two books are our sources for XML case studies. We analyze the solutions offered in each and discuss if we can implement them better.

See [41].

Useful reference, to be used in conjunction with [41] and [42].

Excellent trade journal that provides a developer's web site.

45. James Burke. Connections. Little, Brown & Co. 1978.

46. Scott Peck. The Road Less Taken. Simon and Schuster 1978.

47. Scott Adams. The Dilbert Future. Harperbusiness, 1998.