Contents

1 September

Introduction, administrivia, overview

1. Introduction
   • What kind of computer is the Web?
     • Very large scale (single round trip to the opposite side of the globe at the speed of light takes .13 seconds!)
     • Inherently dynamic and unreliable
     • Multiple administrative domains, willing to grant each other various sorts of privileges
     • Different parts owned by different people
   • What kind of programming language has the Web as its run-time system?
     • must directly address
       • locality
       • security
       • unreliability
     • modularization mechanisms and consistency checking badly needed, but static checking impossible: parts of "global programs" will always be running while others are under development
       conventional static analysis technology (type systems, etc.) not directly applicable
2. Goals of the course:
   1. To survey the "landscape" of issues and current technologies in web programming
   2. To get some reasonably serious hands-on programming experience with distributed and mobile applications
   3. To identify and discuss emerging research issues
3. Logistics
4. The course title... languages for programming the web vs. architectures for web programming vs. web APIs.
   An API (or "software architecture") is a programming-language feature being born.
   A full-scale language distills several such features as simple linguistic mechanisms and combines them in a coherent way.
5. Many of the technologies that we'll discuss involve some sort of mobile code. The following categories give a very rough idea of the varieties of code mobility:
   • Client-server: Both know-how and resources at remote location, activated by local thread of control (e.g. X windows)
   • Remote evaluation: Resources at remote location, know-how is shipped over from local controlling thread (e.g. rsh)
   • Code on demand: Resources are local, code is remote; code is requested and shipped back from remote to local host, where it is executed (e.g. Java applets)
   • Mobile agent: Not only know-how but the agent's thread of control itself travels through the network from node to node (e.g. data mining agents, network managers)
6. Outline of topics for lectures
7. Reading for Wednesday:
   • Luca Cardelli, Global Computation

3 September

Introduction to Java programming

1. Administrivia: course enrollment limits...
2. Overview of Java
   • Most of you probably know more Java than I do, and besides it's boring to hear about new languages from scratch, so I'm going to stick to high-level points.
   • I'll just try to summarize the essential design decisions, following James Gosling and Henry McGilton, The Java Language Environment: A White Paper.
3. The rest of the class will be spent discussing Project 1.
4. N.B. The amount of documentation that I've included in the files in the handout directory should not be taken as a guide! A little more would make the code easier to read...
5. Reading:
   • A Java book of your choice, for example: Ken Arnold and James Gosling, The Java Programming Language.

8 September

The Java Virtual Machine

Room change: from now on, we'll be meeting in LH101, not LH019.

1. Administrivia:
   1. Decide when first assignment is due (probably Wednesday)
   2. Reminder: on Wednesday we'll be choosing project groups for the remainder of the semester; now is the time to get an idea of who you'd like to work with. (If you don't know, don't worry -- we'll make sure everyone gets assigned to a group.)
2. This lecture continues last week's introduction to Java with discussion of some more advanced aspects of the language.
   • The Java Virtual Machine
   • Basic security features
3. Further reading (for those interested -- not required)
   • Gary McGraw and Edward Felten, Java Security: Hostile Applets, Holes, and Antidotes
   • Tim Lindholm and Frank Yellin, The Java Virtual Machine Specification
   • James Gosling, Bill Joy, and Guy Steele, The Java Language Specification

10 September

Applets; the Abstract Windowing Toolkit

[Lecture given by Sundar]

1. Applet programming
2. The Abstract Windowing Toolkit (AWT). (Note that we'll describe the new event handling model included in Jave 1.1, since this is the one that you'll find documented in the on-line API guide; if you look in other books, you'll find mostly descriptions of how things worked in the old Java 1.0.)
3. The Serializable interface.
4. Form project groups.
5. Project 2 starts today.

15 September

More on the AWT; security in Java

1. Administrivia: Class roster
2. Continuation of last Wednesday's material on the AWT
   • AWT protocols (flow of control in an applet)
   • events
3. Basic Java security mechanisms
   • Security managers
   • Class loaders
4. Start discussion of Vijay Saraswat's paper Java is not Typesafe (The sample java code that I showed in class is available here.)
5. Reading for Wednesday:
   • J. Steven Fritzinger and Marianne Mueller, Java Security
   • Vijay Saraswat, Java is not Type Safe

17 September

"Jave is not Typesafe"

• Continuation of Monday's lecture.

22 September

Java RMI

[Lecture given by Sundar]

1. Java's Remote Method Invocation facilities.
2. Reading list:
   • RMI Specification
   • RMI tutorial
   • Birrell, Nelson, and Owicki, Network Objects
   • Birrell, Nelson, Owicki, and Wobber, Distributed Garbage Collection for Network Objects

24 September

Obliq

. [Lecture given by Sundar]

1. Discussion of Luca Cardelli's language Obliq.
2. Readings:
   • Luca Cardelli, A Language with Distributed Scope
   • Luca Cardelli, Obliq Reference Manual
3. Project 3 starts today.
   To get started, look at our sample "Hello" example, a variant of the one in the online Tutorial.

29 September

Obliq (continued); distributed GC

[Lecture given by Sundar]

• Finish discussion of Obliq
• Overview of the distributed garbage collection algorithm used in both DECSRC's Network Objects implementation and Java RMI.

1 October

Review

• It's a month into the course - time to review some of the ground we've covered and talk a little about how the course is going.
• Assignment: Please send me (by Oct 5) an email with a short (couple of paragraphs) evaluation of how the course is going for you.

6 October

Specification of file synchronization; service combinators

• Reminder: send me comments on the course
• Project 4 will be announced later today.
• We'll spend part of the lecture discussing a draft specification of the file synchronization problem.
• In the remaining time, we'll begin discussing Cardelli and Davies's idea of service combinators; we'll continue this on Wednesday.
• Reading:
  • Luca Cardelli and Rowan Davies, Service Combinators for Web Computing
    (Required assignments will be marked with this symbol to distinguish them from other recommended readings.)

8 October

Service combinators

• Discussion: In what sense are Obliq and Java RMI "Web Programming Languages"? What is a web language, anyway?
• Presentation of Service Combinators paper

13 October

Pi-calculus

• We'll begin by finishing off last week's discussion of Service Combinators
• Next, we'll look at Milner, Parrow, and Walker's pi-calculus, a widely used foundational calculus for message-based concurrency. This will lay groundwork for the other, more experimental, foundational calculi that we'll consider after this.
• If there's time left, we'll start on the join-calculus, an extension of (a variant of) the pi-calculus with primitives for location, process migration, and failure detection.
• Reading:
  • Benjamin Pierce, Foundational Calculi for Programming Languages (concentrating on the pi-calculus section)
  • Cedric Fournet and Luc Maranget, The Join-Calculus language, Release 1.01: Documentation and user's manual (pages 1 to 49, concentrating on Chapter 2)
  • Cedric Fournet, Georges Gonthier, Jean-Jacques Levy, Luc Maranget, and Didier Remy, A calculus of mobile agents
  The two papers on the join calculus are complementary, but, for our purposes, neither is ideal. The Tutorial is quite easy reading, but it describes a full-scale distributed programming language (with the "pure" theoretical join-calculus at its core), which can obscure the basic ideas with too much detail. The Calculus of mobile agents paper, on the other hand, is written for a rather theoretical audience and may be hard going for a newcomer to the area. Use both to get a sense of what model of distributed programming is being proposed here.

15 October

Join calculus

• Continued discussion of the join calculus.

20 October

Join calculus

• Distributed features of the join calculus; the DRCHAM (distributed reflexive chemical abstract machine) formalism.

22 October

Ambient calculus

• Reading:
  • Luca Cardelli and Andrew Gordon, Mobile Ambients

27 October

Ambient Calculus

• Continued discussion of the ambient calculus...
• Digression: type systems for concurrent calculi... what would a type system for ambients look like??
• Research question: can the ambient calculus with communication be encoded in the pure ambient calculus?

29 October

Telescript

• Reading:
  • Jim White, Mobile Agents White Paper

3 November

Review; migratory applications

• Discussion of projects 5 and 6.
• In-class exercise (20 minutes):
  1. Where have we been?
     1. What topics have we covered? (Quick outline.)
     2. What major questions have been raised?
  2. What important (or interesting) questions have not yet been raised?
  3. What is the relation between the practical systems we have seen seen and used (RMI, Obliq, Telescript) and the foundational calculi we've discussed (pi-calculus, join-calculus, ambient calculus)?
• Mobile agent frameworks can be classified according to what can move:
  • Just data (traditional RPC)
  • Data and code (RMI, Odyssey)
  • Data, code, and control state (Telescript, Obliq)
  • Data, code, and multiple thread states (join-calculus, Ambit)

5 November

Migratory applications; Aglets

• Having seen the basics of TeleScript in last Wednesday's lecture, we'll start thinking more closely now about actual applications of mobile agent technology.
• Our first topic is a nice paper by Bharat and Cardelli introducing and developing the idea of migratory agents - mobile agents that "take their user-interfaces with them" when they migrate.
• Next, we'll survey the basic mechanisms of IBM's Aglets mobile programming framework, which we'll use in Project 5.
• Project 5 will be announced later today.
• You may also want to get started thinking about Project 6, the details of which are left to individual teams.
• Reading:
  • Krishna A. Bharat and Luca Cardelli, Migratory Applications

10 November

Aglet security; proof-carrying code

1. Briefly discussion of Karjoth, Lange, and Oshima's security model for Aglets. (This paper is fairly high level, so there is not that much to say in detail.)
2. Longer impromptu discussion of Proof-Carrying Code and its potential applications in mobile agents.
3. Reading:
   • Gunter Karjoth, Danny B. Lange, and Mitsuru Oshima, A Security Model for Aglets

13 November

PLAN

1. Two main topics for the rest of the semester:
   • applications for mobile agents
   • security...
2. Protect whom from whom?
3. Standard threats:
   • eavesdropping
   • disclosure
   • intercept/alter
   • replay
   • masquerade
   • resource exhaustion
   • repudiation
4. aspects of security
   • securing underlying transport mechanisms
   • higher-level issues:
     • authentication protocols
     • policy description
5. Plans for the next little while:
   • PLAN language (today)
   • SPI-calculus
   • authentication and policymaking
6. Today's class will be devoted to discussion of the PLAN overview paper.
7. Reading:
   • Michael Hicks, Pankaj Kakkar, Jonathan T. Moore, Carl A. Gunter, and Scott Nettles, PLAN: A Programming Language for Active Networks

17 November

Spi calculus

1. Continuing with the general topic of security, we will begin discussion of Abadi and Gordon's "Calculus of secret agents."
2. Reading:
   • Martin Abadi and Andrew Gordon, A Calculus for Cryptographic Protocols: The Spi Calculus

19 November

Spi calculus; secrecy by typing