Spring Semester 2002


Calendar Students Office Hours Grading Course Materials QuizSite MyGrades


[01] Jan  8
[02] Jan 10
[01] Lab One
[03] Jan 15
[04] Jan 17
[02] Lab Two
Homework One
[05] Jan 22
[06] Jan 24
[03] Lab Three
Homework Two
[07] Jan 29
[08] Jan 31
[04] Lab Four
[09] Feb  5
[10] Feb  7
[05] Lab Five
[11] Feb 12
[12] Feb 14
[06] Lab Six
Homework Three
[13] Feb 19
[14] Feb 21
[07] Lab Seven
PROJECT
[15] Feb 26
[16] MIDTERM
[08] Lab Eight
[17] Mar  5
[18] Mar  7
[09] Lab Nine
Homework Four
[19] SPRING
[20] BREAK
[10] No Lab
[19] Mar 19
[20] Mar 21
[10] Lab Ten
Homework Five
[21] Mar 26
[22] Mar 28
[11] Lab Eleven
[23] Apr  2
[24] Apr  4
[12] Lab Twelve
Homework Six
[25] Apr  9
[26] Apr 11
[13] Lab Thirteen
[27] Apr 16
[28] Apr 18
[14] Lab Fourteen
[29] Apr 23
[30] Apr 25
[16] Lab Fifteen

Calendar and Exams

First here's the schedule of labs:

  Thu 16:40 SE045 Fulya (ferdinc)
  Thu 16:40 BH107 Barry (yinli)

  Fri 10:10 SB230 Chengxiu (ctang) and Fulya (ferdinc)
  Fri 11:15 SB230 Chengxiu (ctang) and Barry (yinli) 

Here's an outline of what will be covered in this class.

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.
Chapter 2. Installing a Web Server: Apache
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.
Chapter 3. HTML Documents and Apache Directory Structure
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.
Chapter 4. Running Apache. Introduction to HTTP
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.
Chapter 5. Introduction to Perl
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).
Chapter 6. Writing CGI Scripts
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).
Chapter 7. Abstracting CGI: readParse
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.
Chapter 8. Object-oriented Perl. CGI Programming with CGI.pm
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.
Chapter 9. Maintaining State with CGI Scripts
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).
Chapter 10. Database Access with CGI Scripts: DBI.pm and MySQL
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.
Chapter 11. Security of Transmission: SSL
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.
Chapter 12. Server-side Programming with PHP.
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.
Chapter 13. Introduction to JavaScript
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.
Chapter 14. Cascading Style Sheets and Dynamic HTML
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.
Chapter 15. Client-side Java: Java Applets.
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.
Chapter 16. Introduction to Java.
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.
Chapter 17. Server-side Java: The Jakarta Tomcat Server.
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.
Chapter 18. Java Servlets.
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).
Chapter 19. Java Server Pages.
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.
Chapter 20. Advanced Java Applications.
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.
Chapter 21. Portable Data: XML
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.
Chapter 22. XML Applications.
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).
Chapter 23. Epilogue
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.


Office Hours

Adrian German (Lecture: LH102, TR 5:45-7:00pm)
9am-10am and 1-2pm MTWR (LH 201D 5-7860, dgerman@indiana.edu),
5:00-6:00pm Friday (in LH016,) or by appointment.

Fulya Erdinc (Labs: R 4:40-5:30pm SE045, F 10:10-11:00am SB230 (with ctang))
12:00-13:00 TW (LH 016, ferdinc@indiana.edu)

Yinggang (Barry) Li (Labs: R 4:40-5:30pm BH107, F 11:15-12:05pm SB230 (with ctang))
1-3pm F (LH 120 , yinli@indiana.edu)

Chengxiu Tang (Labs: F 10:10-11:00am SB230 (with ferdinc), F 11:15-12:05pm SB230 (with yinli))
2-4 F (LH 201H, ctang@indiana.edu)


Grading

A348 is offered in the same rooms and at the same time with A548. The syllabus is the same for A348 (undergraduate) and A548 (graduate) students. There are about 6-7 assignments per semester, two in-class closed-book exams (the midterm and the final) weekly lab assignments that need to be turned in during the lab, and a semester instructor-coordinated group project.

The assignments and the exams have two components: a basic component that is required of all students (this part tests understanding of the concepts presented in class and demonstrated in the lab modules) and a more advanced component that is optional for the undergraduates but is required of the graduate students. The basic component of an assignment accounts for 100% of the assignment grade of an undergraduate student, and for 67% of that of a graduate student.

The advanced component of the assignment usually requires a certain amount of independent study on the part of the student, as it refers to concepts and procedures mentioned but not presented in great detail in lectures or lab modules. This component is optional for the undegraduates, but it accounts for 33% of the assignment grade for the students enrolled in A548. Quizzes and in-class assignments are identical for all students, and team projects (coordinated by the instructor) are all of the same difficulty.

Where teams are composed of both graduate and undergraduate students the graduate students are expected to assume additional responsibilities in terms of team coordination, project implementation and final presentation, and contributions to the project will be graded separately.

Course grades will be determined as follows:

Component Category Weight
Assignments (5-6 this semester) HWK 30%
Group Project PRJ 20%
Midterm Exam MID 15%
Final Exam FIN 15%
Lab Assignments (about 10-12) LAB 20%

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.


Course Materials

There is no text required for this class. All materials will be posted on the web (lecture notes and lab notes). I include here a list of books on which the notes have been based. I meant to have the notes typeset and printed for this semester so I can distribute them through the IU Bookstore as a class packet. I'll make the packet available over the web, as I typeset it this semester and will make sure it's available to ClassPak by the end of November for the Spring semester. Be sure to bring a notebook to class, take notes, and stay current on everything that's posted on the web.

The list of books below is what the forthcoming packet is based on.

Annotated Bibliography

Not all are competing books, most are complementary, all are related.

1. Cricket Liu, Jerry Peek, Russ Jones, Bryan Buus, and Adrian Nye. Managing Internet Information Services. O'Reilly & Associates, 1994.

One of the first comprehensive reviews, now somewhat dated. Useful to understand what was popular before the web, and from a historical development perspective. Also has a good bare-bones CGI tutorial.
2. Net.Genesis and Devra Hall. Build a WebSite. The Programmer's Guide to Creating, Building, and Maintaining a Web Site. Prima Publishing, 1995.
One of the early choices for an A348 textbook (in 1996). Somewhat dated, good as a reference in many ways.
3. Douglas Comer. The Internet Book. Everything you need to know about computer networking and how the Internet works. Third Edition. Prentice Hall, 2000.
This book is to the Internet networking what the Feynman lectures were to Physics (by and large). Outstanding overall presentation.
4. Paul W. Abrahams and Bruce R. Larson. Unix for the Impatient. Second Edition. Addison-Wesley, 1997.
Useful to jump-start one's interaction with Unix, or as a reference.
5. Gail Anderson and Paul Anderson. The Unix C Shell Field Guide. Prentice Hall, 1986.
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.
6. Deborah S. Ray and Eric J. Ray. Visual Quickstart Guide: Unix. Peachpit Press, 1998.
Visual quickstart for those (not few) intimidated by Unix.
7. Larry Wall, Tom Christiansen, Jon Orwant. Programming Perl. Third Edition, O'Reilly and Associates, 2000.
The authoritative description of the language, by the author.
8. Damian Conway. Object Oriented Perl. Manning Publications, 2000.
A wonderful, general description of the object-oriented aspects of Perl. The book contains three useful cross-language appendices.
9. Lincoln Stein. How to Set Up and Maintain a Web Site. Second Edition. Addison-Wesley, 1997.
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.
10. Stephen Spainhour and Robert Eckstein. Webmaster in a Nutshell. Second Edition. O'Reilly and Associates, 1999.
Succint, almost complete, overview of all things webmaster. Cannot be used as a hands-on tutorial in any way, though.
11. Peter Wainwright. Professional Apache. Wrox Press, 1999.
Good description of installation and customization of Apache. It lacks a purpose (or focus) though, although coverage is complete.
11.1 Ben Laurie, Peter Laurie. Apache, The Definitive Guide.
Used for Chapter 13 mostly (but not only).
12. Steven Brenner, Edwin Aoki. Introduction to CGI/Perl: Getting Started with Web Scripts. This title is out of print now. 1995.
Extremely old, but beautiful book on which our chapter 7 is based.
13. Scott Guelich, Linda Mui, Gunther Birznieks, Shishir Gundavaram. CGI Programming with Perl. Second Edition, O'Reilly and Associates, 2000.
Case studies in CGI. Reading this book is as refreshing as solving a crossword puzzle, i.e. its makes an excellent complementary reading.
14. Lincoln Stein. Official Guide to Programming with CGI.pm. The standard for Building Web Scripts. John Wiley, 1998.
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.
15. Lincoln Stein and Doug MacEachern. Writing Apache Modules with Perl and C. O'Reilly and Associates, 1999.
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.
16. Paul DuBois. MySQL. New Riders, 2000.
Extremely thorough treatment of MySQL and SQL, with many examples. Our one-stop reference for all things RDBMS in this class.
17. Alligator Descartes and Tim Bunce. Programming the Perl DBI. O'Reilly and Associates, 2000.
Our reference for DBI.pm this book is even a bit more general than needed, including a few chapters that complement DuBois [16].
18. Jesus Castagnetto, Harish Rawat, Sascha Schumann, Chris Scollo, Deepak Veliath. Professional PHP Programming. Wrox Press, 1999.
Our treatment of PHP is based on this book and Chapter 16 of [10].
19. Benay Dara-Abrams, Drew Dara-Abrams, Trevor Peace, Bebo White. Supporting Web Servers. Prentice Hall PTR, 2001.
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].
20. Eric Larson, Brian Stephens. Administrating Web Servers, Security and Maintenance. Prentice Hall PTR, 2000.
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.
21. David Flanagan. Java in a Nutshell. A Desktop Quick Reference. Third Edition. O'Reilly and Associates, 1999.
Good reference on the core Java language APIs.
22. David Flanagan, Jim Farley, William Crawford and Kris Magnusson. Java Enterprise in a Nutshell. A Desktop Quick Reference. O'Reilly and Associates, 1999.
Servlets, RMI, JDBC, not covered in [21].
23. Peter van der Linden. Just Java 1.2. Fourth Edition. Prentice Hall PTR and Sun Microsystems Press, 1998.
Very entertaining and complete overview of Java. Especially the part on threads is a work of genius in its extremely simple and straightforward presentation.
24. Peter van der Linden. Not just Java. A Technology Overview. Prentice Hall PTR and Sun Microsystems Press, 1999.
Review of accompanying, complementary technologies.
25. Troy Bryan Downing. Developing Distributed Java Applications. Java RMI. Remote Method Invocation. IDG Books Worldwide, 1998.
Very good, complete description of RMI. Parts of chapters 18, and 20 rely on concepts covered in this book.
26. Marty Hall, Core Servlets and Java Server Pages. Prentice Hall PTR and Sun Picrosystems Press, 2000.
Our treatment of servlets and JSP is based partially on this.
27. Duane K. Fields, Mark A. Kolb. Web Development with Java Server Pages. A Practical Guide. Manning Publications, 2000.
The JSP coverage is based on this and Marty Hall [26].
28. Marty Hall. Core Web Programming. Prentice Hall PTR, 2001.
Updated, enhanced version of [26].
29. David Flanagan. Java Examples in a Nutshell. O'Reilly, 1997.
The source for any Java jumpstart. Complete range of excellent examples.
30. Jason Hunter, with William Crawford. Java Servlet Programming. O'Reilly and Associates, 1998.
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.
31. David Flanagan. Javascript. The Definitive Guide. Third Edition. O'Reilly and Associates, 1998.
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.
32. William R. Cheswick, Steven M. Bellovin. Firewalls and Internet Security. Repelling the Wily Hacker. Addison-Wesley, 1994.
Recommended reading for issues, concepts, principles of security.
33. Lincoln Stein. Web Security. A Step-by-Step Reference Guide. Addison-Wesley, 1998.
Essentially a checklist from the once maintainer of the WWW Security FAQ.
34. Evi Nemeth, Garth Snyder, Scott Seebass, Trent R. Hein. Unix System Administration Handbook. Prentice Hall PTR, 1995.
Handbook of Unix system administration techniques (should one need them).
35. Marc Abrams (editor). World Wide Web: Beyond the Basics. Prentice Hall, 1998.
An early attempt at summarizing all existing implementation technologies.
36. Dan Livingston, Micah Brown. Essential CSS and DHTML for the Web Professional. Prentice Hall, 1999.
Practical examples. Our chapter 14 is based on it.
37. Steven Holzner. Web Developer.com Guide to Dynamic HTML. John Wiley, 1997.
Same as Livingston and Brown [36], focusing more on Internet Explorer.
38. Steven Holzner. Inside XML. New Riders Publishing, 2000.
Excellent overview of XML on both sides (server and client side), with many hands-on projects. We use it in chapter 21.
39. Brett Mc Laughlin, Mike Loukides. Java and XML. O'Reilly, 2000.
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).
40. Rob Gordon and Stephen Talley, Essential JMF: Java Media Framework. Prentice Hall PTR, 1999.
On implementing the simple videophone. This book is not enough, but very useful, and it is well written.
41. Khun Yee Fung, XSLT: Working with XML and HTML. Addison-Wesley, 2001.
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.
42. Benoit Marchal, Applied XML Solutions. SAMS, 2000.
See [41].
43. Michael Kay. XSLT Programmer's Reference. Wrox Press 2000.
Useful reference, to be used in conjunction with [41] and [42].
44. http://www.webtechniques.com/
Excellent trade journal that provides a developer's web site.
I've also used the following books, sporadically, and for very specific, focused reasons. These books don't deal directly with the mechanics of web programming, instead they reflect, indirectly, (on) related aspects of (web) life. We might quote from them, from time to time.

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.


Last updated: Jan 15, 2002 by Adrian German for A348/A548