![]() |
![]() 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:
Chapter 1. Unix Overview: What You Need to Know to Get Started
Here's an outline of what will be covered in this class.
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)
We start with the idea of a remote computer that stores your
files, to which one connects with a utility such as
Chapter 2. Installing a Web Server: Apache
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.
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
Chapter 5. Introduction to Perl
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 (
Chapter 6. Writing CGI Scripts
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
Chapter 7. Abstracting CGI: 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).
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
Chapter 23. Epilogue
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.
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.