Class 01: Getting Started

Held Monday, January 22, 2001

Summary

We begin the "course" with a consideration of its content, its purpose, and your expectations. In the second half of today's class, we begin consideration of the Perl programming language.

Notes

Due

• Philip and Alex's Guide

Assignments

• Homework 1

Notes

• Fill out the introductory survey
• Get started on Blackboard!
• William has conjunctivitis, so I'm nto as prepared as I'd hoped to be (and won't be).

Overview

• About the Independent Study
• Some Administrative Issues
  • Expectations
  • Projects
  • Timing
• A quick-and-dirty introduction to Perl

About the Independent Study

• Intent: Give you an opportunity to bring together diverse knowledge for a particular set of applications: Large-scale interactive Web sites.
• What things will you need to use, learn, or think about this semester?
  • Databases
  • Operating systems, particularly synchronization and some practical OS matters, such as scheduling jobs
  • Human factors in computing systems (I expect you to conduct careful testing of your user interfaces)
  • Some programming language issues
  • ...
• We'll be relying on a number of different systems for your projects
  • OS: Linux
  • Web Server: Apache
  • Database: PostgreSQL
  • Language: Perl
  • Authentication: Kerberos (maybe)
• While there are twenty-odd students planning to participate in this independent study, it is not a course.
  • You are responsible for taking the initiative in many issues.
  • I don't know a lot about some of these topics, so we'll be learning together.
  • While I may teach some issues, after the first half of the semester, I'll primarily serve as project leader.
• Within the next week, you'll need to select a project so that we can turn in your independent study applications. We'll return to project topics a little bit later.
  • Plan to work in groups of three.

Expectations, Revisited

• When you signed up for this independent, you agreed to a set of expectations. I'll remind you of them (or at least some of them).
• Work time: 10 hpw for 2 credits, 15 hpw for 4 credits. (That's hours per week, not average hours per week.)
  • Since different people may have different abilities, I'm considering effort as much as outcome in the course.
  • You can count time spent in the big meeting and time spent in the Exotic Programming Languages Study Group.
• Work log: Whenever you do work on this class, you must write it down at the time the work occurs.
  • Log: Start time, Stop time, type of task, lengths of interruptions, total time, and summary of lessons learned or accomplished.
  • I am likely to ask for your work log at unexpected times, so carry it with you.
• Project: You must select (and do your best to complete) one or more significant Web-based projects.
• Attendance: You must attend at least one session per week. (Those of you receiving 4 credits may attend two, but the second counts for only one hour.)
• Initiative: You must be prepared to do a significant amount of the work on your own (or within your small group).
• Collaboration: You must do you share of the group work.

Optional Issues

• We have three (well, 2.5) machines reserved for this independent study. Hence, you'll have the chance to configure (with root access).
• We may want to consider using some authentication and user account system (so that all services can share data).
• If you want to purchase .org domain names, you can investigate how one configures a machine to serve multiple domains.

Approximate Schedule

• Week One: Sam: Course Overview, Introduction to Perl
• Week Two: Sam: CGI Scripting
• Week Three: Students: CGI Script Demos; Sam: Perl Modules
• Week Four: Students: UI Design; Sam: Intro to SQL
• Week Five: Students: UI Testing; Sam: Perl DBI
• Week Six: Students: Datbase Design; Sam: Apache Issues
• Week Seven: Project Design, including timetable
• Week Eight: Code Walkthroughs
• Break
• Week Nine: Code Walkthroughs
• Week Ten: Code Walkthroughs
• Week Eleven: Draft Sites Released
• Week Twelve: Code Walkthroughs
• Week Thirteen: Code Walkthroughs
• Week Fourteen: Public Presentations

Reflections on Reading

• I think Philip and Alex's Guide provides a useful overview of issues in building medium- and large-scale Web services.
• I'd like to hear what you learned, thought, discovered, objected to, whatever from the book.

Potential Projects

• Your project must involve a significant interface-design component and a significant database component.
• Commercial
  • Jarrod's Golf site (if he's willing to have collaborators)
  • Andy and Jon's consulting (if they're willing to have collaborators)
  • ...
• Institutional service
  • Four-year planner
  • Improved plan server (with less administration)
  • ...
• Community service
  • Something for the mental health center.
  • Restaurant information service
  • ...
• Outside service
  • PKAL Faculty Database
  • ...
• General services
  • Mailing list server
  • Scheduler (e.g., to find common meeting times)

Perl Basics

• The language: Built by hackers for hackers. Grown organically.
• The advantage: Lots of quick-and-dirty ways to do things
  • Memory
  • Pattern matching
  • Dictionaries (called "hashes")
  • Dynamically typed
• The disadvantage: Every programmer can use his or her own style.
  • Dozens of ways to do the same thing.
  • Code can be hard to read.
  • Getting more difficult to master the whole language.
• Another disadvantage: No formal definition
  • Defined by its implementation.

Variables

• Untyped, essentially.
• Four basic categories:
  • Normal variable (one datum)
  • Array (indexed by integers)
  • Hash (indexed by strings)
  • References (pointers, left until later)
  • Objects (essentially just syntax with pointers; left until later)
• You can tell the type by usage:
  • $name: datum
  • @name: array
  • $name[integer-expression]: array element
  • %name: hash
  • $name{string}: hash element
• You can initialize arrays by listing the elements within parentheses.
• You can initialize hashes by
• For example,

  $i = 10;
  $name = "SamR";
  $names[5] = "Whatever";
  @grades = ( "A", "B", "C", "D", "F" );
  %gradevals = { "A" => 4.0,
                 "B" => 3.0,
                 "C" => 2.0,
                 "D" => 1.0,
                 "F" => 0.0 };
  $firstname{"Rebelsky"} = "Sam"; 
  

• Variables don't need to be declared.
• But there are also ways to limit scope
  • my creates a local variable that disappears when the block exits and is only available within the scope.
  • local termporarily replaces a global variable. The old value is restored when the block exits. However, the new value of the v ariable is accessible to all called procedures.
  • Plan to experiment with variations.

Basic Operations

• Assignment. Uses =.
• Function calls. Uses C/Java/etc. notation.
• Input. Ugly.
  • <STDIN> reads one line from standard input and assigns it to the variable $_.
  • $var = <STDIN> reads one line from standard input and assigns it to the variable $var
  • File input is similar (see notes later).
• Output. Somewhat clearer.
  • print val1, val2, ... valn
  • print handle val1, ... valn
  • Ports include STDOUT (normal output), STDERR (standard output), and filehandles.

Control

• Sequencing. Instructions are executed one-by-one. Must be separated by semicolons.
• Conditionals

  if (test) {
    result1;
  }
  elseif (test) {
    result2;
  }
  ...
  else {
    resultn;
  }
  

• Yes, those braces are necessary.
• There's also an unless. We won't worry about it right now.
• Some Perl programmers use logical operations for control.
• While loops

  while (test) {
    stuff;
  }
  

• Stepping through the elements of a list or array

  foreach $var (array) {
    stuff;
  }
  

• C's bastardized for loop

  for (start; stop; step) {
    stuff;
  }
  

I/O

• To open a file for writing,
  open(HANDLE, "> fname");
• E.g., open(HTML, "> $base.html");
• Write to it with
  print HTML "<html>\n";
• Close it when you're done.
• To open a file for reading,
  open(HANDLE, "< fname");
• Read from it using <HANDLE>
• For example,

  if (!open(DATA, "< datafile"))) {
    print STDERR "Couldn't open data file.\n";
    crash_and_burn();
  }
  while ($line = <DATA>) {
    chop($line); # Get rid of the carriage return
    @parts = split(/:/, $line);
    print $parts[0], "\n";
  }
  close(DATA);
  

Regular Expressions

• Built in.
• Typical usage:

  if ($stringvar =~ m/regexp/) {
    ...
  }
  

• Read more in the Perl book.

Miscellaneous

• The "from here" mark, << provides an intersting way to grab a lot of text (typically for output, but also for assigning to variables).

  print STDOUT <<"STOPHERE";
  <html>
  <head>
  <title>$title</title>
  </head>
  STOPHERE
  

• I won't teach you everything (or perhaps even all that much). You need to learn how to figure things out from the Perl book, man pages, examples on the Web, or each other. (You can ask me questions, too.)